hermes-agent/tui_gateway/contracts/tools_mcp_plugins.py
Teknium 9bcbe7b5df
feat(i18n): pluggable, layered language packs across core, Desktop and TUI (#126296)
* feat(i18n): layered catalogs — plugin packs and user overlay over bundled locales

* feat(tui): i18n layer — en catalog, nanostore runtime, RPC pack loader, _keys.tui.json emitter

ui-tui/src/i18n/: en.ts (facade over topical siblings under en/), types.ts
(Translations + dotted TranslationKey derived from en), runtime.ts ($locale/
$catalog atoms, translateFrom active→en→key, pack merge with string→fn
wrapping for {0}/{1} placeholders), loader.ts (display.language →
i18n.catalog {lang, surface:'tui'}, English when the method is missing),
useT()/useLocale() hooks, t() for non-React code. useConfigSync feeds the
loader from the existing config.get full hydration. `npm run i18n:keys`
writes locales/_keys.tui.json (sorted flat key list) and runs before build.

* feat(plugins): provides_locales manifest field, ctx.register_locale/register_locale_dir, manifest-only language packs

* chore(tui): split en catalog siblings by lane (slash sibling)

* feat(plugins): validate language packs — parse, text-only, key-subset WARN against en / _keys exports

* feat(tui_gateway): i18n.languages / i18n.catalog RPC + regenerated contracts

* feat(config): display.language accepts any supported_languages() id, refuses unknown ids with the list

* docs(i18n): language packs user guide, pluggable display.language, plugin developer section, AGENTS notes

* feat(plugins): report language-pack layers in the mid-run activation summary

* feat(tui): wire status bar, composer placeholders, hotkey help and approval/clarify/confirm prompts through i18n

StatusRule maps compared state values (ready/running…/summoning) to catalog
text at render via displayStatus(); hotkeys()/placeholder() resolve lazily so
a pack that arrives after boot applies. Catalog grows to 81 keys.

* feat(desktop): pluggable app locales — registry, host.i18n.registerAppLocale, backend packs, keys emitter

- Locale widens to string (BundledLocale keeps the union); TRANSLATIONS stays
  the bundled record and every consumer resolves through the registry.
- src/i18n/registry.ts: registerAppLocale(id, {endonym, rtl, translations})
  layers partial packs (nested or flat dotted) over bundled/en via
  mergeTranslations; a string over a function-valued en entry becomes a
  positional {0}/{1} formatter; $appLocaleVersion bumps so translators
  re-render; per-source disposers + replaceAppLocaleSource for atomic swaps.
- Backend packs: i18n.languages + i18n.catalog {surface:'desktop'} feed the
  registry as source 'backend' (method-not-found is silent); re-synced on
  socket open, display.language change and profile switch. A saved pack-only
  language is promoted once its pack registers.
- SDK: host.i18n.registerAppLocale / languageOptions; ctx.i18n.registerAppLocale
  tracked for unload. Docs in the desktop plugin SDK guide + skill reference.
- Language switcher lists bundled ∪ registered ∪ backend, endonym-only; RTL
  from the registry (applyDocumentLocale takes rtl).
- npm run i18n:keys emits locales/_keys.desktop.json (wired into build).

* i18n(cli): route /topup + /subscription copy through t() (cli.billing.*, cli.subscription.*)

Module-level copy tables and modal choice tuples in cli_billing_mixin.py froze
English at import, before display.language was known. They are now key tables /
builder functions evaluated at call time; every user-facing line in the /usage
balance block, /subscription and the five /topup screens reads the catalog.
Choice VALUES stay English identifiers. Fragment-assembled status lines
(Plan: … → cancels · $x left · renews …) become full templates.

* i18n(gateway): exec-approval card contract + base/run/run_busy/run_inbound replies through t()

- base_exec_approval: EA_* English constants stay; add ea_header_text()/ea_reason_label_text()/
  ea_smart_deny_line_text()/ea_default_reason_text()/ea_action_labels()/approval_timed_out_notice()
  accessors; deadline + timed-out notice resolve via gateway.exec_approval.*
- BasePlatformAdapter._EA_HEADER/_EA_REASON_LABEL/_EA_SMART_DENY_LINE/_EA_ACTION_LABELS become
  properties (adapters still shadow them with markup class attrs)
- run.py: provider error replies table holds catalog keys; _CONTEXT_OVERFLOW_REPLY -> _context_overflow_reply()
- run_busy/run_inbound: typed approval + slash-confirm matchers accept English ∪ approval.inputs.* (t())
- locales/en.yaml: gateway.exec_approval/busy/errors/... namespaces

* i18n(cli): wire modal, loops, agent-setup mixins through t() (cli.* keys)

* i18n(platforms): route Slack, Matrix and Feishu user-facing text through t()

Exec-approval markup overrides (_EA_HEADER/_EA_REASON_LABEL/_EA_SMART_DENY_LINE/
_EA_ACTION_LABELS) become per-call properties over the shared
gateway.exec_approval.* contract keys, so Slack's 3000-char section budget
measures the resolved template. Slack _APPROVAL_DECISIONS/_CONFIRM_DECISIONS,
Feishu _APPROVAL_LABEL_MAP and Matrix _EA_LEGEND/_EA_TYPED_HINT turn into
key tables resolved at click time; the Matrix typed hints become whole
sentences per offered tier instead of spliced fragments. Slack button labels
are cut to 75 chars and select placeholders to 150 after translation; the
model-facing clarify fallback answer ('choice N') stays English while the
card copy localizes.

locales/en.yaml gains the gateway.exec_approval.* contract keys plus the
platform.shared.* / platform.slack.* / platform.matrix.* / platform.feishu.*
namespaces (and the keys for the other adapters wired in follow-up commits).

* i18n(gateway): run_turn / run_turn_runner / approval-settle copy through t()

- status hints, proxy errors, background task notices, progress heartbeats, session info lines
- tool progress chrome (tool_head/tool_pending/tool_preview/tool_verbose) shared by base.format_tool_event
- run_turn_runner:1406 Chinese clarify placeholder -> gateway.clarify.native_stream_placeholder (zh text kept in zh.yaml)
- _UNEXPECTED_SILENCE_REPLY/_CLARIFY_EXPIRED_NOTICE -> accessor functions

* i18n(platforms): route Google Chat and Teams user-facing text through t()

Google Chat clarify card, typing placeholder, orphan-card labels and the whole
/setup-files reply set (module constants become platform.google_chat.setup_files.*
keys resolved at reply time). The attachment-fallback notice that shipped
hardcoded in Spanish is keyed with an English en value; es.yaml carries the
original Spanish text for those four keys.

Teams approval card header/reason use the gateway.exec_approval.* contract,
_APPROVAL_LABELS becomes a key table resolved at click time, and the meeting
summary writer resolves its section headings/fallbacks per render.

* i18n(platforms): route LINE, WeCom, email, DingTalk, IRC and Home Assistant text through t()

LINE default copy constants become catalog keys resolved in __init__ (the
LINE_*_TEXT / extra.* operator overrides still win); the busy-ack bypass
matcher keys on the leading emoji marker only, so it keeps firing once the
gateway busy heads are localized. WeCom media size/format notices that shipped
hardcoded in Chinese are keyed with English en values and zh.yaml carries the
original Chinese text. DingTalk emotion bubbles resolve per send.

* i18n(cli): route /model switch output and -q status lines through t() (cli.model.*, cli.single_query.*)

Switch-summary labels shared with the gateway reuse gateway.model.* keys
(provider/context/max-output/capabilities/prompt-caching); CLI-only variants
(glyph or no-backtick forms) live under cli.model.*. The hand-padded /model usage
block becomes a (form, description-key) table padded at render time so the
command syntax stays fixed while descriptions translate. -q 'Error:' reuses
gateway.model.error_prefix.

* i18n(cli): route TUI panel/hint/placeholder copy through t() (cli.tui.*)

_APPROVAL_CHOICE_LABELS and _TUI_MODAL_HINTS become key tables resolved at
render time; vault/sudo panel bodies are one catalog value per panel split on
newline; inline plurals use <key>_one/<key>_other. Adds the cli.* namespace
(shared/tui/voice/render/subagents/dock) to locales/en.yaml.

* i18n(cli): voice/wake-word CLI copy through t() (cli.voice.*)

RuntimeError texts raised in _voice_start_recording are human copy (callers
print {e}) and are keyed; the Termux requirement-check match stays English.
Wake state ids stay internal, only their labels localize.

* i18n(cli): live-work dock, subagent monitor and render copy through t()

cli.subagents.* / cli.dock.* / cli.render.*; count fragments pluralize via
_one/_other keys, verdict table holds keys resolved at paint time so width
clipping measures the translated text.

* i18n(gateway): unauthorized/pairing, voice, topics, shutdown, startup, notifications, kanban pings through t()

* i18n(cli): move tips + composer placeholders into the catalog (tips.tNNN / tips.placeholder.pNN)

get_random_tip()/get_random_composer_placeholder() pick a key from the English catalog
(the parity baseline, probed once per process) and resolve it through t() for the active
language, so language packs translate tips like any other string. Also lands the cli.*
en.yaml namespace consumed by the CLI info/help/error-copy wiring in the next commit.

* i18n(cli): wire chat-turn + session mixins through t(); kanban log trimmer matches t() output

* test(cli): assert TUI/dock/voice copy via t(key); prove labels resolve at render time

Pinned-English assertions in the approval-UI, live-work dock and voice tests now
go through the catalog. New test swaps the catalog after import and checks the
approval panel + hint row follow it (the reason _APPROVAL_CHOICE_LABELS and
_TUI_MODAL_HINTS became key tables).

* i18n(cli): route CLI info/help/error copy through t() (cli.* namespace)

cli_info_mixin: /help consumes CommandDef.describe() (added to commands.py: slash.<name>.description
with fallback to .description), section titles/skill/quick-command headers, /tools, /toolsets,
/usage labels, /context, /whoami, /insights, /gateway status, tool-progress labels, bang-shell
denials, MCP config-watch + /reload-mcp confirm/reload lines, /reload-skills, and the session-store
warning all read the catalog at call time (module-level label tables became functions so the
active language is honoured after startup). cli.py: worktree cleanup, tirith warning, show_config
(labels re-padded at print time), quick/plugin/skill slash-command errors, ambiguous-command hint,
stdin error, gateway start, profile warning. cli_chat_error_copy / cli_unknown_command /
cli_output / cli_init_mixin: chat error panel copy, did-you-mean lines, n-more / yes-no prompt
(localized affirmative initial alongside 'y'), unknown-toolsets warning.

* i18n(w1a): wire agent display/explainers/approval + slash registry/help through t()

- hermes_cli/commands.py: CommandDef.describe() resolves slash.<name>.description
  at call time; category labels via slash.category.*; help/alias/usage suffixes
  via slash.shared.*; gateway_help_lines and commands_platforms/slash_exec use them.
- agent/display.py: display.verb.* resolved at call time via get_tool_verb();
  bridge/spinner/thinking-verb/cute-row/failure/preview/diff text via display.*.
- agent/turn_explainers.py: exit-reason / persistence-cause tables become call-time
  lookups (explainer.exit.*, explainer.persistence.*, explainer.file_mutation.*).
- agent/background_review.py, session_activity.py, context_breakdown.py,
  status_output.py: review summaries, iteration progress, context notices.
- tools/approval.py, approval_context.py: approval.summary.*, approval.noun.*,
  approval.window.* pluralized keys.
- gateway/slash_commands*.py: remaining raw strings (busy, whoami, platform,
  bundles, memory, skills, approvals, set_home, diff, update, debug, profile,
  heartbeat, refine, review, subgoal, loop, retry, compress codex path, save,
  sessions, model guard/errors, agents rows, topup, login). HISTORY_UNREADABLE
  keeps its English constant; callers use history_unreadable() ->
  gateway.shared.history_unreadable.
- locales/en.yaml: new approval/display/explainer/slash blocks + gateway leftovers.

* i18n(telegram): route adapter chat copy through t()

Approval card (header/reason/smart-deny as HTML-escaped properties), inline
button labels, callback toasts (cut at Telegram's 200-char cap), model/choice
pickers, clarify/update/slash-confirm prompts, gmail-triage labels and the
inbound-media failure notice now come from the catalog. _UNAUTHORIZED is a
lazy _unauthorized() so the import no longer binds a language. The command
menu carries a language+payload fingerprint (forum scopes re-register on
change) and BotCommand descriptions are cut at 256.

Adds gateway.exec_approval.* (WAVE2 contract), platform.telegram.*,
platform.discord.* and the slash.*.description keys the Discord table shares
with the CLI registry to locales/en.yaml.

* i18n(gateway/platforms): whatsapp_cloud, yuanbao, weixin, signal, api_server copy through t()

- whatsapp_cloud: clarify list/buttons, approve/deny + slash-confirm labels via platform.whatsapp.* (t()-then-truncate at 20/24/72 caps); _EA_HEADER becomes a property wrapping ea_header_text()
- yuanbao: SLOW_RESPONSE_MESSAGE -> slow_response_message() (platform.yuanbao.slow_response_notice; zh keeps the original text); cron-wrapper markers centralized as module constants for strip_cron_wrapper
- api_server: PROVIDER_AUTH_FAILED_LABEL/PROVIDER_RATE_LIMITED_LABEL stay English for run.py matchers; user_text() renders via t()
- signal/_format_wait, weixin voice caption, openai_routes transformed notice
- run_turn: second _UNEXPECTED_SILENCE_REPLY consumer -> accessor

* i18n(discord): route adapter chat copy through t()

Native slash-command table becomes _NATIVE_SLASH_COMMAND_SPECS holding catalog
keys; _native_slash_commands() resolves descriptions, parameter descriptions
and Choice names for the active language, each cut at Discord's 100-char cap,
and the app-command sync fingerprint now includes get_language() so a
display.language change re-syncs. Exec-approval card (gateway.exec_approval.*
contract), slash-confirm / clarify / update views, model+choice pickers,
thread creation, forum titles, voice acks, the response-truncation notice,
the unauthorized-slash security alert and the media upload-size notices all
read from platform.discord.*. Decorator-declared button labels are relabelled
in __init__ (80-char cap); embed titles cut at 256, select placeholders at
150, option label/description at 100. _UNAUTHORIZED is a lazy _unauthorized().

* i18n(cli): wire status-bar, stream, terminal mixins + terminal_input through t(); rename kwargs that shadow t(key)

* i18n: wire hermes_cli/cli_commands_mixin.py slash-command copy through t()

- 431 new leaves under cli.commands.<cmd>.* in locales/en.yaml; 12 rows reuse
  existing gateway.* keys (rollback, diff, resume, branch, btw, model, reasoning)
  via a _gt() helper so CLI and gateway replies stay identical.
- Module-level English tables (_BUSY_MODE_*, _REASONING_TOGGLES, _HATCH_PROGRESS,
  _DIFF_LABELS, _LOCAL_ENGINE_LINES) become call-time catalog lookups keyed by id.
- Verb tables (Enabling/Disabling, Paused/Resumed/Triggered, planned/done,
  Updating/Generating) are one full template per variant; plurals use
  <key>_one/<key>_other via _tn(); hand-padded column labels (/snapshot list)
  translate the value and re-pad at the call site.
- Multi-line usage blocks are single catalog values split with _lines().
- Model-facing system notes and DB-stored reasons stay English (EXCLUDED).

* tests: assert /handoff, /worktree, /login CLI copy via t(key) instead of pinned English

* test(i18n): pin Telegram/Discord adapter catalog wiring

Lazy unauthorized notice, exec-approval contract keys, HTML escaping before
Telegram <b> wrapping, 200-char toast / 256-char BotCommand caps, Discord
100-char app-command text and 80-char button caps, and language-bearing
command-menu fingerprints on both platforms.

* i18n: reconcile cli.shared on/off vs enabled/disabled after lane merge

* i18n: describe() in TUI-gateway slash listings; localize TUI exit resume hint

* i18n(tr): translate bundled catalog + tui pack

* i18n(ja): translate bundled catalog + tui pack

* i18n(ko): translate bundled catalog + tui pack

* i18n(zh): translate bundled catalog + tui pack

* i18n(fr): translate bundled catalog + tui pack

* i18n(af): translate bundled catalog + tui pack

* i18n(uk): translate bundled catalog + tui pack

* i18n(ar): translate bundled catalog + tui pack

* i18n(pt): translate bundled catalog + tui pack

* i18n(it): translate bundled catalog + tui pack

* i18n(es): translate bundled catalog + tui pack

* i18n(zh-hant): translate bundled catalog + tui pack

* i18n(ru): translate bundled catalog + tui pack

* i18n(hu): translate bundled catalog + tui pack

* i18n(hu): translate pre-existing English-valued leftovers (kanban wake, /context, /status, fast labels)

* i18n(de): translate bundled catalog + tui pack

* i18n(ga): translate bundled catalog + tui pack

* test(i18n): fixture matches _normalize_lang(lang, home) signature

* i18n(tui): scaffold userMessages/slashCmd en siblings

* i18n(tui): wire secure prompts + content tables

* feat(tui): i18n — wire billing, subscription, connection-setup and journey overlays

Adds en siblings billing.ts / subscription.ts / connection.ts (namespaces
billing, subscription, connection, journey) and routes every user-facing
literal in billingOverlay, subscriptionOverlay, connectionSetupOverlay and
journey through useT()/messages(). Module-level label tables became lazy
(scopeStillDeniedResult(), verbOf(T, action)); auto-reload rows dispatch on
stable ids instead of label text. Regenerates locales/_keys.tui.json.

* i18n(tui): wire slash ops/wake replies

* i18n(tui): wire pickers (modelPicker, activeSessionSwitcher, petPicker)

* i18n(tui): wire slash core/debug/setup replies

* i18n(tui): wire hubs (agents overlay/panel/controls, skills, plugins)

* i18n(tui): wire slash session/topup/subscription replies

* i18n(tui): wire chat bits (branding, thinking, messageLine, loaders, todo, queued, banner, entry)

* i18n(tui): register t3 siblings (pickers, hubs, secure, content, chatBits) and regenerate keys

* i18n(tui): wire userMessages copy through the userMessages namespace

* i18n(tui): lazy-copy test for userMessages, regenerate _keys.tui.json

* i18n(tui): wire session/gateway/lib text through the TUI catalog (lane t2)

Adds en siblings session.ts, gatewayMsg.ts, libText.ts (namespaces session,
gatewayMsg, libText) and routes user-facing literals in app/{useMainApp,
useSessionLifecycle,useInputHandlers,turnController,createServerRequestHandler,
setupHandoff,createGatewayEventHandler}.ts, gatewayClient displayed reasons,
lib/*, domain/*, hooks/* through t()/messages(). Status-bar state values that
code compares against, backend-matched strings, log lines, model-bound text,
and machine 'error:' prefixes stay literal. Regenerates locales/_keys.tui.json
(232 keys).

* i18n: serve bundled locales/<lang>.tui.yaml under overlay/packs; TUI pack parity test; regen _keys.tui.json (1250)

* i18n: translate pre-existing English stubs in bundled locales (424 leaves, 14 locales)

* tui: i18n-export-en script (English templates for pack translators)

* docs(i18n): bundled TUI packs are the bottom layer of the tui surface

* i18n(ru): translate TUI pack

* i18n(ar): translate TUI pack

* i18n(es): translate TUI pack

* i18n(pt): translate TUI pack

* i18n(ko): translate TUI pack

* i18n(de): translate TUI pack

* i18n(ja): translate TUI pack

* i18n(fr): translate TUI pack

* i18n(tr): translate TUI pack

* i18n(it): translate TUI pack

* i18n(zh): translate TUI pack

* i18n(zh-hant): translate TUI pack

* i18n(hu): translate TUI pack

* i18n(uk): translate TUI pack

1,169 missing keys translated; 81 pre-existing kept byte-identical. Parity OK missing=0 extra=0 placeholder_mismatch=0 empty=0.

Deliberately identical to en: chatBits.branding.mcpSummary ({0} MCP), chatBits.thinking.agentsHint ((/agents)), session.main.voiceStt (◉ STT), session.main.voiceTtsSuffix ( [tts]), slashCmd.core.help.tuiSection (TUI), slashCmd.core.history.hermesTag (Hermes #{0}), slashCmd.debug.heapdump.heapPath (heapdump: {0}), slashCmd.debug.mem.rss (rss), subscription.stepUp.title (Remote Spending — product feature name, as in core catalog), content.faces.* (glyph-only kaomoji).

* i18n(ga): translate TUI pack

* i18n(af): translate TUI pack

* plugin_guard: locale catalogs in language packs step down the agent-config family

A translated status line such as "Updating AGENTS.md" in locales/<lang>.yaml is UI text the loader
reads as a string leaf; it cannot edit a file. The bundled en.yaml itself tripped agent_config_mod
at critical, making any faithful language pack uninstallable. Injection shapes keep full severity.

* plugin_validate_locales: read key exports with utf-8-sig (Windows footgun lint)

* i18n(relay): route relay adapter prompt copy through t(); drop dead import-bound approval header

Adds platform.relay.* (5 keys) to en and all 16 bundled locales, reusing the sibling platform
translations for the confirm buttons and the Other option.

* ci: fix TUI import order, MDX table pipe, main's overflow-warning wording in all locales; fresh-install fixture carries the i18n kernel

- ui-tui/src/i18n/en.ts: perfectionist/sort-imports (slash before slashCmd)
- docs plugins/index.md: escape the | inside the provides_locales table cell (MDX parsed <id> as JSX)
- display.notice.uncompressed_context_overflow: adopt main's wording (names compression.enabled: false
  and /compact) in en + 16 locales; the guardrail test pins that phrase
- tests/scripts/test_fresh_source_install.py: the installer tail now resolves CLI text through
  agent.i18n, so the fixture tree carries the i18n kernel + en.yaml (not the agent runtime)

* docs(desktop-plugin-sdk): double-backtick the template-literal example (MDX evaluated ${n})

* test(e2e): display.language is validated against the live language set; exclude it from the arbitrary-string set property

* commands: keep the localized COMMANDS/COMMANDS_BY_CATEGORY module __getattr__ after the compat block removal

* build: never write locales/_keys.*.json from the desktop/TUI builds; regenerate the committed desktop key export

The desktop build regenerated locales/_keys.desktop.json in the checkout, so a
hermes update that rebuilt the app left the tree dirty (Desktop update E2E:
'M locales/_keys.desktop.json'). The key exports are committed artifacts pinned
to en.ts by apps/desktop/scripts/i18n-keys.test.mjs and ui-tui i18n:keys:check;
builds read them, never write them. Regenerated after main's new desktop strings.

* test: unbreak two main-red timing tests the PR merge-ref inherits

- test_local_runtime racing fake publishes the modern state record (legacy pid-only
  records are rejected since 65ff3ad353; main has been red on this test since)
- test_run_progress_topics ManyProgressLinesAgent waits for the first bubble instead of
  a fixed 0.35s, which a loaded CI runner does not always meet

* chore(i18n): regenerate desktop key catalog for main's new strings (model pricing, copy changelog)

* test(e2e): torture-chamber fd monitor confirms a deleted sidecar is still held before calling it a leak

SQLite's WAL last-close unlinks -shm before closing its descriptor (unixShmUnmap, then
unixShmPurge), so a healthy close shows a (deleted) -shm for microseconds; the 20ms poll
occasionally caught that window on the short-lived opener and failed the episode.

* chore(i18n): regenerate desktop key catalog for main's telemetry/consent strings

* chore(i18n): regenerate desktop key catalog after main sync

---------

Co-authored-by: Teknium <[email protected]>
2026-09-28 14:16:18 -07:00

773 lines
24 KiB
Python

"""Tools / toolsets / MCP servers / plugins / skills / learning graph / reload contracts
(``tui_gateway/methods_tools.py``).
Every ``mcp.servers.*``, ``mcp.catalog``, ``skills.manage`` and ``plugins.manage`` handler runs under
``_profile_scoped_rpc`` and the desktop routes them via ``requestGatewayForProfile`` /
``requestForBot``, so all of them accept the optional ``profile`` key.
"""
from __future__ import annotations
from pydantic import Field
from .base import JsonValue, Params, Result, WireEnum
from .common import OpenModel, ProfileParams, SessionLiveInfo
from .connectors_operation import CatalogAppState, CatalogTier
from .registry import method
class _SessionScoped(Params):
"""Handlers that look a live session up with ``_sessions.get(params.get("session_id"))``: an
absent / unknown id falls back to the launch profile's config, so it is never required."""
session_id: str | None = None
# ── tools / toolsets ──────────────────────────────────────────────────────────────────────────
class ToolsetRow(Result):
"""One row of ``methods_tools._toolset_rows``; ``tools`` only when the caller asked for them
(``tools.list``)."""
name: str
description: str
tool_count: int
enabled: bool
tools: list[str] | None = None
class ToolsetsListResult(Result):
toolsets: list[ToolsetRow]
method("tools.list", params=_SessionScoped, result=ToolsetsListResult,
doc="Every toolset with its resolved tool names, flagged against the session's (or config's) enabled set.")
method("toolsets.list", params=_SessionScoped, result=ToolsetsListResult,
doc="Toolset summaries (no tool names) for the desktop Toolsets tab.")
class ToolShowRow(Result):
name: str
description: str
class ToolShowSection(Result):
name: str
tools: list[ToolShowRow]
class ToolsShowResult(Result):
sections: list[ToolShowSection]
total: int
method("tools.show", params=_SessionScoped, result=ToolsShowResult,
doc="The /tools listing grouped by toolset, including tools deferred behind the tool_search bridge.")
class ToolsAction(WireEnum):
enable = "enable"
disable = "disable"
class ToolsConfigureParams(Params):
"""``names`` are toolset keys or ``server:tool`` MCP targets; with ``session_id`` the live session's
profile is authoritative and its agent is rebuilt."""
action: ToolsAction
names: list[str]
session_id: str | None = None
profile: str | None = None
class ToolsConfigureResult(Result):
changed: list[str]
enabled_toolsets: list[str]
info: SessionLiveInfo | None = None
missing_servers: list[str]
reset: bool
unknown: list[str]
method("tools.configure", params=ToolsConfigureParams, result=ToolsConfigureResult,
doc="Persist a toolset / MCP enable-disable change and rebuild the session agent so it takes effect now.")
# ── reload ────────────────────────────────────────────────────────────────────────────────────
class ReloadEnvParams(Params):
pass
class ReloadEnvResult(Result):
updated: int
method("reload.env", params=ReloadEnvParams, result=ReloadEnvResult,
doc="Re-read ~/.hermes/.env (CLI /reload parity); built agents keep their pool until /new.")
class ReloadMcpParams(Params):
"""Without ``confirm`` the handler may answer ``confirm_required`` (per ``approvals.mcp_reload_confirm``);
``always`` persists the opt-out; ``rev`` is the config revision the caller wants loaded (coalescing)."""
session_id: str | None = None
confirm: bool = False
always: bool = False
rev: str | None = None
class ReloadMcpStatus(WireEnum):
confirm_required = "confirm_required"
reloaded = "reloaded"
class ReloadMcpResult(Result):
status: ReloadMcpStatus
message: str | None = None
loaded_rev: str | None = None
coalesced: bool | None = None
turn_isolation: bool | None = None
host_ack: JsonValue | None = None
method("reload.mcp", params=ReloadMcpParams, result=ReloadMcpResult,
doc="Tear down and rediscover MCP servers for every live session (prompt cache is invalidated).")
# ── skills ────────────────────────────────────────────────────────────────────────────────────
class SkillsAction(WireEnum):
list = "list"
search = "search"
install = "install"
browse = "browse"
inspect = "inspect"
class SkillsManageParams(ProfileParams):
"""``query`` is the search text / hub identifier / browse page (digits); ``page`` / ``page_size``
apply to ``browse``."""
action: SkillsAction = SkillsAction.list
query: str | None = None
page: int | None = None
page_size: int | None = None
class SkillHubHit(Result):
name: str
description: str
class SkillBrowseItem(OpenModel):
"""``hermes_cli.skills_hub.browse_skills`` row."""
name: str = ""
description: str = ""
source: str = ""
trust: str | None = None
identifier: str | None = None
class SkillInspectInfo(OpenModel):
"""``hermes_cli.skills_hub.inspect_skill``; ``{}`` when the identifier resolves nowhere."""
name: str | None = None
description: str | None = None
source: str | None = None
identifier: str | None = None
tags: list[str] | None = None
skill_md_preview: str | None = None
class SkillsManageResult(Result):
"""Shape follows the action: ``list`` → ``skills`` (category → names); ``search`` → ``results``;
``install`` → ``installed`` + ``name``; ``browse`` → ``items`` + paging; ``inspect`` → ``info``."""
skills: dict[str, list[str]] | None = None
results: list[SkillHubHit] | None = None
installed: bool | None = None
name: str | None = None
items: list[SkillBrowseItem] | None = None
page: int | None = None
total_pages: int | None = None
total: int | None = None
info: SkillInspectInfo | None = None
method("skills.manage", params=SkillsManageParams, result=SkillsManageResult,
doc="Skills hub backend: list the profile's skills or search / browse / inspect / install from the hub.")
class SkillsReloadParams(Params):
"""``session_id`` binds the rescan to that session's profile and workspace (project skills);
``profile`` scopes a session-less rescan."""
session_id: str | None = None
profile: str | None = None
class SkillCommandRef(Result):
name: str
description: str = ""
class SkillsReloadDiff(OpenModel):
"""``agent.skill_commands.reload_skills``."""
added: list[SkillCommandRef] = Field(default_factory=list)
removed: list[SkillCommandRef] = Field(default_factory=list)
unchanged: list[str] = Field(default_factory=list)
total: int = 0
commands: int = 0
class SkillsReloadResult(Result):
output: str
result: SkillsReloadDiff
method("skills.reload", params=SkillsReloadParams, result=SkillsReloadResult,
doc="Re-scan skill dirs; the pre-rendered ``output`` is what /reload-skills prints.")
# ── learning graph (/journey) ─────────────────────────────────────────────────────────────────
class LearningFramesParams(Params):
cols: int | None = None
rows: int | None = None
frames: int | None = None
class LearningFrame(Result):
"""``agent.learning_graph_render.render_graph`` projection; ``grid`` rows are lists of
``[text, styleKey, alpha?, hexOverride?]`` runs."""
reveal: float
date: str
visible: int
grid: list[list[JsonValue]]
labels: list[dict[str, JsonValue]] = Field(default_factory=list)
class LearningLegendItem(Result):
glyph: str
label: str
style: str | None = None
color: str | None = None
class LearningNodeRow(Result):
id: str
glyph: str
label: str
fullLabel: str # noqa: N815 — wire key from learning_graph_render._bucket_rows
meta: str
body: str
style: str
class LearningBucketRow(Result):
index: int
label: str
date: str
skills: int
memories: int
total: int
category: str | None = None
color: str | None = None
nodes: list[LearningNodeRow]
class LearningAxis(Result):
start: str
end: str
class LearningFramesResult(Result):
frames: list[LearningFrame]
legend: list[LearningLegendItem]
categories: list[LearningLegendItem]
buckets: list[LearningBucketRow]
summary: list[str]
axis: LearningAxis
count: int
cols: int
rows: int
method("learning.frames", params=LearningFramesParams, result=LearningFramesResult,
doc="Pre-render the /journey timeline (frames + legend/summary) so the TUI walks it locally.")
class LearningNodeParams(Params):
id: str | None = None
class LearningEditParams(LearningNodeParams):
content: str | None = None
class LearningMutationResult(Result):
"""``agent.learning_mutations`` — ``ok: false`` carries the reason in ``message``."""
ok: bool
message: str | None = None
class LearningDetailResult(LearningMutationResult):
kind: str | None = None
id: str | None = None
label: str | None = None
content: str | None = None
method("learning.detail", params=LearningNodeParams, result=LearningDetailResult,
doc="Node content (SKILL.md or memory chunk) for an edit prefill.")
method("learning.delete", params=LearningNodeParams, result=LearningMutationResult,
doc="Archive a skill (restorable via curator) or remove a memory chunk.")
method("learning.edit", params=LearningEditParams, result=LearningMutationResult,
doc="Rewrite a node's content (SKILL.md or memory chunk).")
# ── MCP catalog + per-profile server lifecycle ────────────────────────────────────────────────
class McpCatalogEntry(Result):
name: str
description: str
connector_slug: str | None = None
installed: bool
enabled: bool
requires: list[str]
transport: str
class McpCatalogResult(Result):
servers: list[McpCatalogEntry]
method("mcp.catalog", params=ProfileParams, result=McpCatalogResult,
doc="Curated MCP presets with per-profile installed/enabled state and the env keys each needs.")
class McpServerSource(WireEnum):
config = "config"
plugin = "plugin"
class McpServerSummary(Result):
"""``tui_gateway/mcp_rpc_helpers.summarize_server`` — a server's config without secret values."""
name: str
transport: str
url: str | None = None
command: str | None = None
args: list[str]
env: list[str]
auth: str | None = None
oauth_tokens_present: bool | None = None
enabled: bool
tools: JsonValue | None = None
source: McpServerSource
plugin: str | None = None
class McpServersListResult(Result):
servers: list[McpServerSummary]
method("mcp.servers.list", params=ProfileParams, result=McpServersListResult,
doc="Configured MCP servers for the (scoped) profile, secrets redacted to env-key names.")
class McpRuntimeStatus(WireEnum):
connected = "connected"
disabled = "disabled"
connecting = "connecting"
failed = "failed"
lazy = "lazy"
configured = "configured"
class McpServerRuntimeRow(Result):
"""Safe projection of ``tools.mcp_tool_discovery.get_mcp_status`` rows."""
name: str
transport: str
tools: int
connected: bool
disabled: bool
status: McpRuntimeStatus
source: McpServerSource
plugin: str | None = None
class McpServersStatusResult(Result):
servers: list[McpServerRuntimeRow]
checked_at: int
method("mcp.servers.status", params=ProfileParams, result=McpServersStatusResult,
doc="Cached runtime state per configured server; never connects, probes, or starts auth.")
class McpServerNameParams(ProfileParams):
name: str
class McpServersAddParams(McpServerNameParams):
"""``preset`` (catalog id) and/or ``config`` (url/command/args/env/headers/auth/tools); a
``bearer_token`` is written to the profile's .env, only the header template persists."""
preset: str | None = None
config: dict[str, JsonValue] | None = None
bearer_token: str | None = None
class McpServersAddResult(Result):
ok: bool
name: str
server: McpServerSummary
method("mcp.servers.add", params=McpServersAddParams, result=McpServersAddResult,
doc="Add a server to the profile's config from a catalog preset and/or an explicit config.")
class McpServersSetApiKeyParams(McpServerNameParams):
value: str
env_var: str | None = None
class McpServersSetApiKeyResult(Result):
ok: bool
name: str
env_var: str
server: McpServerSummary
method("mcp.servers.set_api_key", params=McpServersSetApiKeyParams, result=McpServersSetApiKeyResult,
doc="Store a credential in the profile's .env and reference it from the server config (header or env).")
class McpProbeTool(Result):
name: str
description: str
class McpServersTestResult(Result):
"""``ok: false`` carries ``error``; ``prompts`` / ``resources`` are only counted on success."""
ok: bool
tools: list[McpProbeTool]
error: str | None = None
prompts: int | None = None
resources: int | None = None
oauth_needed: bool
oauth_tokens_present: bool | None = None
method("mcp.servers.test", params=McpServerNameParams, result=McpServersTestResult,
doc="Connect, list tools, disconnect — an OAuth server with no token on disk is reported as not ok.")
class McpServersRemoveResult(Result):
ok: bool
removed: bool
method("mcp.servers.remove", params=McpServerNameParams, result=McpServersRemoveResult,
doc="Drop a server from the profile's config.yaml.")
class McpOauthStartParams(McpServerNameParams):
"""With ``client_redirect_uri`` the CLIENT hosts the loopback and relays the code via
``mcp.servers.oauth.callback``."""
client_redirect_uri: str | None = None
class McpOauthStartResult(Result):
ok: bool
session_id: str
auth_url: str
flow: str
method("mcp.servers.oauth.start", params=McpOauthStartParams, result=McpOauthStartResult,
doc="Begin a PKCE OAuth flow; the client opens auth_url and polls mcp.servers.oauth.poll.")
class McpOauthFlowParams(McpServerNameParams):
"""``session_id`` is the OAuth flow id returned by ``oauth.start`` (not a gateway session)."""
session_id: str
class McpOauthPollStatus(WireEnum):
pending = "pending"
approved = "approved"
error = "error"
class McpOauthPollResult(Result):
ok: bool
status: McpOauthPollStatus
session_id: str | None = None
error_message: str | None = None
auth_url: str | None = None
tools: list[McpProbeTool] | None = None
method("mcp.servers.oauth.poll", params=McpOauthFlowParams, result=McpOauthPollResult,
doc="Poll a flow; approved persists tokens for the profile and returns the probed tools.")
class McpOauthCancelResult(Result):
ok: bool
status: str | None = None
error_message: str | None = None
method("mcp.servers.oauth.cancel", params=McpOauthFlowParams, result=McpOauthCancelResult,
doc="Cancel a flow owned by the resolved profile, waking its callback worker.")
class McpOauthCallbackParams(McpOauthFlowParams):
code: str | None = None
state: str | None = None
error: str | None = None
# RFC 9207 issuer; extra="forbid" would otherwise 4000 the desktop relay that always sends it.
iss: str | None = None
class McpOauthCallbackResult(Result):
ok: bool
session_id: str | None = None
error_message: str | None = None
method("mcp.servers.oauth.callback", params=McpOauthCallbackParams, result=McpOauthCallbackResult,
doc="Relay a client-captured redirect into a client_redirect_uri flow.")
# ── plugins ───────────────────────────────────────────────────────────────────────────────────
class PluginsListParams(Params):
pass
class LegacyPluginRow(Result):
name: str
version: str
enabled: bool
class PluginsListResult(Result):
plugins: list[LegacyPluginRow]
method("plugins.list", params=PluginsListParams, result=PluginsListResult,
doc="Loaded plugin manager entries (legacy flat view); the Plugins Hub uses plugins.manage list.")
class PluginsAction(WireEnum):
list = "list"
toggle = "toggle"
install = "install"
update = "update"
remove = "remove"
settings = "settings"
onboarding = "onboarding"
class PluginsManageParams(ProfileParams):
"""``toggle``: ``key``/``name`` + ``enable``; ``install``: ``identifier``/``repo`` or ``catalog_name``
(+ ``force``, ``enable``, ``ref``); ``update``: ``name`` (+ ``accept_capabilities`` to apply a re-pin
that widened the plugin after the user confirmed the ``delta``); ``remove``: ``name`` (user installs only);
``settings``: ``key`` + ``values`` (``{setting_key: value}``, non-secret schema keys only)."""
action: PluginsAction = PluginsAction.list
key: str | None = None
name: str | None = None
enable: bool | None = None
identifier: str | None = None
repo: str | None = None
catalog_name: str | None = None
force: bool | None = None
ref: str | None = None
accept_capabilities: bool | None = None
values: dict[str, JsonValue] | None = None
class PluginSettingFieldType(WireEnum):
string = "string"
number = "number"
boolean = "boolean"
enum = "enum"
secret = "secret"
json = "json"
class PluginSettingField(Result):
"""One ``config_schema`` key of a plugin manifest, rendered by the Plugins hub
(``hermes_cli.plugins_settings.plugin_settings_fields``). ``secret`` fields carry no value: ``env``
names the ``.env`` variable and ``has_value`` whether it is set."""
key: str
type: PluginSettingFieldType
label: str
description: str
required: bool
value: JsonValue | None = None
default: JsonValue | None = None
choices: list[str] | None = None
env: str | None = None
has_value: bool | None = None
class PluginServerState(WireEnum):
connected = "connected"
app_not_running = "app_not_running"
hermes_not_connected = "hermes_not_connected"
endpoint_unavailable = "endpoint_unavailable"
no_interactive_session = "no_interactive_session"
version_too_old = "version_too_old"
missing_app = "missing_app"
unknown = "unknown"
class PluginServerRow(Result):
name: str
state: PluginServerState
sentence: str
class AgentPluginRow(Result):
"""``methods_tools._plugin_rows`` + ``plugins_cmd_catalog.catalog_row_fields`` provenance."""
name: str
key: str
version: str
description: str
source: str
status: str
portable: bool
install_dir: str
has_desktop_half: bool
servers: list[PluginServerRow]
catalog_name: str | None = None
catalog_tier: str | None = None
installed_sha: str | None = None
catalog_sha: str | None = None
catalog_version: str | None = None
update_available: bool | None = None
pinned_sha: str | None = None
settings_schema: list[PluginSettingField] | None = None
class PluginLiveServer(Result):
"""One plugin MCP server connected at activation: its callable tool names, or the reason it did not connect."""
name: str
connected: bool
tools: list[str] = Field(default_factory=list)
error: str | None = None
class PluginLiveSkill(Result):
"""One plugin skill usable now through ``skill_view`` (qualified ``<plugin>:<skill>``)."""
name: str
description: str = ""
class PluginLiveNow(Result):
mcp_servers: list[PluginLiveServer] = Field(default_factory=list)
skills: list[PluginLiveSkill] = Field(default_factory=list)
class PluginActivation(Result):
"""What a plugin loaded mid-run does NOW vs later (``hermes_cli.plugins_activation``). ``activated_now``
kinds (``{kind: [names]}``): ``gateway_commands`` (slash names), ``locales`` (``<lang>.<surface>``
language-pack layers), ``gateway_transforms`` / ``hooks`` (hook
names), ``callbacks`` (platforms / ``slack:<action_id>``) — live in the running gateway once it reloaded
(``gateway_reloaded``). ``live_now``: the plugin's MCP servers (connected, with their tools, or the
error) and skills, usable in every open chat of the profile from its next turn — the chats also get a
note listing them. ``deferred`` kinds: ``tools`` (Python tool names) and ``prompt`` (section ids)
apply from the next session."""
name: str
key: str
activated_now: dict[str, list[str]] = Field(default_factory=dict)
live_now: PluginLiveNow | None = None
deferred: dict[str, list[str]] = Field(default_factory=dict)
class OnboardingCatalogPlugin(Result):
"""A catalog plugin curated for the onboarding card (``onboarding: true``) that this OS runs.
``app_state`` is the pinned ``plugin.json`` declaration judged on this host; ``sentence`` names what
is missing (empty when present or unknown)."""
name: str
title: str
description: str
tier: CatalogTier
platforms: list[str]
app_state: CatalogAppState
sentence: str
class PluginsManageResult(Result):
"""``list`` → ``plugins`` + counts; ``toggle`` → ``ok``/``unchanged``/``restart_required``/``name``
(the canonical key written)/``plugin``; ``install`` → ``hermes_cli.plugins_cmd.dashboard_install_plugin``'s
ok payload; ``toggle``/``install``/``update`` that loaded a plugin also carry ``gateway_reloaded`` (the
running gateway picked it up and re-wired its handlers) and ``activation`` — the honest split of what is
live now vs deferred, so ``restart_required`` is True only when no gateway answered; ``update`` → ``ok``/``unchanged``/``sha``, or ``ok=false`` + ``consent_required`` with the
``delta`` (``{surface: [added...]}``) / ``delta_lines`` a widened pin adds — nothing changed until the
client retries with ``accept_capabilities``; ``remove`` → ``ok``/``name`` plus
``cleared_memory_provider`` when the removed plugin was the live ``memory.provider``."""
plugins: list[AgentPluginRow] | None = None
user_count: int | None = None
bundled_count: int | None = None
ok: bool | None = None
unchanged: bool | None = None
restart_required: bool | None = None
gateway_reloaded: bool | None = None
activation: PluginActivation | None = None
cleared_memory_provider: bool | None = None
name: str | None = None
plugin: AgentPluginRow | None = None
plugin_name: str | None = None
warnings: list[str] | None = None
missing_env: list[str] | None = None
# ``install`` → the manifest's ``python_dependencies`` the installer applied (``[]`` when none).
python_dependencies: list[str] | None = None
# ``install`` from the catalog → the entry's informational ``known_issues`` (``[]`` when none).
known_issues: list[str] | None = None
after_install_path: str | None = None
enabled: bool | None = None
sha: str | None = None
consent_required: bool | None = None
delta: dict[str, list[str]] | None = None
delta_lines: list[str] | None = None
error: str | None = None
written: list[str] | None = None
# ``onboarding`` → the curated catalog plugins for the onboarding card.
onboarding: list[OnboardingCatalogPlugin] | None = None
method("plugins.manage", params=PluginsManageParams, result=PluginsManageResult,
doc="Plugins Hub backend: list installed plugins, toggle, git-install, re-pin a catalog install, "
"or remove a user install.")