84 Commits

Author	SHA1	Message	Date
John Paul Soliva	bb3011a202	fix(video_gen): resolve OpenRouter and DeepInfra credentials per profile, not from os.environ ... The OpenRouter video backend read OPENROUTER_API_KEY and OPENROUTER_BASE_URL straight from os.environ. That broke two setups: - A key added with `hermes auth add openrouter` (API key or OAuth) lives in the credential pool, not the environment. Chat and image_gen/openrouter find it through resolve_runtime_provider. video_gen reported OpenRouter unavailable, and generate() returned missing_credentials. - On a multiplexed gateway, os.environ holds the launch profile's .env. A routed profile's video jobs were submitted, polled and downloaded with the launch profile's key and billed to that account. A profile whose key lived only in its own .env could not use the backend at all. The backend now resolves (api_key, base_url) with resolve_runtime_provider(requested="openrouter"), the same call image_gen/openrouter makes. generate() resolves once and passes the pair to submit, poll and download. With a round-robin pool, resolving per request would poll with a different account's key than the one that created the job. OpenAICompatibleVideoGenProvider, which the DeepInfra video backend uses, had the same raw reads of <NAME>_API_KEY and <NAME>_BASE_URL. Both now go through get_secret_str, as image_gen/deepinfra already does.	2026-09-23 07:49:35 -07:00
alt-glitch	550d74c62f	fix: manage_catalog documented under its own setup toolset; post-hook ownership contract exercises it ... tools-reference.md listed manage_catalog under the connections section, which the reference-docs contract resolves against the connections toolset. The agent-runtime post-hook ownership test enumerates every tool in AGENT_RUNTIME_POST_HOOK_TOOL_NAMES; manage_catalog now runs through both executor paths there.	2026-09-23 08:04:33 +05:30
alt-glitch	31e59b9441	feat: setup agent can search the catalog and install plugins and skills through the approval card ... The setup profile's `setup` toolset was empty. It now carries one tool, manage_catalog: - search: catalog plugins (the Plugins tab's live catalog resolver) and hub skills, with whether each is already installed in the default profile. Read-only. - install: opens the same connection operation manage_connections opens, with rows of kind plugin / skill. Nothing installs until the user approves a row. An approved row installs into `default` (or the profile the Advanced modal named) through dashboard_install_plugin / the hub's headless install, so the catalog pin, kill list, security scan and live activation (#119644) are the host's. The row settles with the live MCP tool names and the plugin's skill. The model sends catalog ids and an action only; every other key is refused before anything runs. An unknown id or a plugin this OS cannot run is drawn failed with the installer's own text. Anywhere a catalog card cannot be drawn (TUI, CLI, messaging, registry dispatch) the result is the `hermes plugins install` / `hermes skills install` pointer. - contract: plugin/skill targets follow the MCP transitions. - run.apply_answer / reissue route a card answer to the module that owns the operation. - tool_search: `setup` joins the direct-surface toolsets, so the guide's one tool is never deferred behind tool_search. - docs: tools reference, toolsets reference, plugin catalog page. Linear NS-964.	2026-09-23 08:04:33 +05:30
teknium1	e636aedebf	fix: preserve known file baselines across partial rereads	2026-09-21 18:39:24 -07:00
teknium1	65b0ff38ea	feat(terminal): heartbeat notifications for long background processes ... `terminal(background=true, heartbeat=N)` emits a `heartbeat` event every N seconds (floor 60) carrying only the output produced since the previous one, plus the usual completion notice. The agent stays current on a long bounded job (merge train, full test suite, deploy) and reacts to a failure within N seconds instead of at exit. Why: `notify=true` fires once at exit, so multi-hour merge trains ran silently — the parent's prompt cache went cold and every "what's up" cost 5–10 rediscovery calls; 30 days of batch sessions show 4,930 hand status polls (14% of all tool calls). `notify=[pattern]` cannot serve this: its lifetime cap (8) exists precisely to stop periodic output from flooding the agent. Mechanism: one daemon timer thread for every heartbeat session (reader threads block on the pipe and cannot keep time); delta output via a total-ingested counter over the rolling buffer; heartbeats only where the completion notice can be delivered (same async-support/subagent gates), never after exit. `heartbeat_seconds` is checkpointed. Rendered on CLI, gateway and TUI through the existing process-notification paths.	2026-09-21 15:02:49 -07:00
Siddharth Balyan	afc3b7c6f3	feat(connectors): one backend-owned connection operation, with a setup card on Desktop, TUI and CLI (#111008) ... * feat(connectors): the desktop connects apps through one backend-owned operation Re-based onto main after #109517, #110368, #110574 and #110843 landed as squash merges (e0ef0eb9c3, d105376b21, ee2f5629b8, 1ab32b212b): the branch's history no longer shared a base with main, so this is the PR's exact delta against +3762/-1470, identical to the branch tip 05d7f2d3d5. The fifteen commits it carried, in order: --- feat(connectors): the wire follows the connector contract (six-state status, required toolkit metadata, connectionId on mint) Hermes types exactly what the contract page writes: /tmp/magic/CONTRACT-TOOLKIT-METADATA.resolved.md (carriers: portal PR2 `sid/connection-api` for the enum and account rows, the portal contract branch on top of it for the list metadata). No optional-for-compat fields, no fallback branch, no seven-state word left in the tree. A gateway that does not speak this contract fails validation loudly. Wire (tools/connectors/gateway/wire.py): `ConnectionStatus` is the six values, `pending` covering the vendor's INITIALIZING and INITIATED; `ConnectorListItem` requires title, description, https iconUrl and authKind, and carries activeConnectionId when the session binds an account; `ConnectorListResponse` types a page whole with its total; `ConnectorAccount` and `ConnectorAccountsResponse` type the account routes; a mint result names its connectionId on `initiated` and never on `failed`; CONNECTION_REQUIRED carries connectUrl and connectionId together or not at all; `account` exists on the execute call and is never sent while multi-account is off. Client: `list_connectors(search, connected)` refuses a search under three characters before any request and parses every page whole; `list_accounts` and `account_status` read the account routes, 404 `connection_not_found` is None and 429 raises `RateLimited(retry_after)`. Watcher: the target keeps the account id the mint named and the toolkit's title and icon from one list read before the card is emitted; `_status_for` is the one seam between the watcher and the gateway's status source (the list walk today; the per-account route replaces that body only). `pending` and a missing status move nothing; revoked and inactive are failed. Desktop: `ConnectorRow` is the strict list item; `ConnectorRowSeed` is what a tool call's args can say; `connection.request`/`update` targets carry `connection_id`, `title`, `icon_url`; the mark ladder is glyph, vendor icon as a plain image, favicon, monogram. Tests run red first: wire rejects the retired words and the missing metadata; client search minimum, execute omits account, account_status 404/429; managed targets carry the metadata and the account id, a pending row moves nothing; the logo ladder order; the store passes the fields through. --- feat(connectors): onboarding connect-first rides the connection operation The guided first build had its own connector surface: a 2 s connectors.list poll loop, an auto-open of every minted link, a hidden "[setup] links opened" note that painted as a user bubble, CONNECT FIRST rows in the transcript, and a "Start with N apps connected" composer pill that sent the go signal early. Delete all of it. The build session's first manage_connections connect now shows the same card as any chat, and the settled tool result is the go signal. Deleted: store/first-build-connectors.ts, assistant-ui/first-build-connectors.tsx (nothing rendered it any more), lib/first-build-start.ts, onboarding-chat/start.tsx, the first-build session markers in handoff-receipt.ts, the connectionRows / latestConnectorPart helpers they were the last readers of, and the five strings only they used. The runbook (setup-profile.ts::connectFirstRunbook) now describes the operation's real contract: one connect call with every picked slug, one card with a row per app, blocks until settled, a per-app result of connected / skipped / not_connected. No wait, no "Start with", no "already active" branch (the result never carried it), and no offer to re-mint: Try again and Continue live on the card, and a Continue means the user moved on. Tests (red first): the runbook names one connect call and its per-app result and never the retired model actions; the no-account rule survives an empty pick. --- feat(connectors): the registry is keyed by profile, every watch read is bounded by the deadline, connectionId is optional, connect and execute carry returnTo and op Registry (P1-14): tools/connectors/live.py keys an operation by (profile home, session key). Two multiplexed profiles can carry the same timestamp-based session key; the tool thread opens under its turn's profile override and the RPC side names the session record's profile home, the default profile resolving to the process home on both sides. Watch reads (P1-8 residual): list_connectors takes a per-page timeout and the watcher bounds each read by the operation's remaining deadline (floor one second), so a stalled gateway page cannot hold the operation past its deadline. Contract follow-up from the portal handoff (/tmp/magic/HANDOFF-HERMES-PR3-PORTAL-CONTRACT.md): connectionId on a mint result and on CONNECTION_REQUIRED is plain Optional (a no-auth toolkit answers active with none; a failed mint answers with neither link nor id); a target without one has nothing to watch. Connect and execute requests carry returnTo (hermes-desktop | hermes-desktop-dev | portal) and op, so the vendor's done page can send the browser back to the app; the call sites and the deep-link handler follow in the next commit. Tests, red first: two profiles share a session key without seeing each other; each watch read shrinks with the deadline; the client honours a per-page timeout; the optional id; the two request fields. The fakes' list_connectors accept the timeout keyword; two wrapper spies that did not were the cause of a 300 s hang under the per-file harness. --- feat(connectors): an MCP target runs on the shared connection operation manage_connections ran MCP targets as a renderer errand: the desktop card ran the catalog lookup, the install and the OAuth flow, then told the backend what had happened, and every surface without a card got `unavailable` plus two terminal commands. That left the outcome in the renderer's word, and left the model unable to connect an MCP server anywhere but the desktop. The backend now owns the work, the way it already owns a managed connector. `prepare` starts the OAuth flow in process and points the browser at the backend's own callback route; an install that still needs credentials waits pending and publishes their names as `required_env`; `observe` reads the flow or the install worker on every tick. The worker itself moved out of tui_gateway/mcp_oauth_sessions.py into tools/connectors/mcp_oauth.py, and that module now calls it, so the Capabilities tab keeps its RPC session table. The card may only say approved, skipped or continue: a claim of any other state moves nothing. With that, `renderer_flow` and the `unavailable` state have no producer left and are gone from the contract. Off the desktop there is no card, so the action runs at once and the result carries the authorization URL for the user to open. Try again reaches the same work: `_reissue` dispatches on `target.kind`, so an MCP row re-runs its own install, enable or OAuth instead of minting a managed gateway link. (cherry picked from commit fa0438c4121807604e7c983ba42b901314a1305b) --- feat(connectors): the MCP card projects the operation instead of running the flow The MCP setup card used to own the work: it called the catalog, ran installMcpCatalogEntry, polled the action, drove the OAuth window, and then told the backend what had happened through connection.respond. That made the renderer a second authority on target state, so an install that finished after the window closed, or a card that never mounted, left the operation with a state nobody could correct. PR3 moves that work to the backend, so the card has one job left: show the operation and send the user's consent. McpSetupPending now renders request.targets the way ConnectorOffer renders them: one row per target, one verb by (action, state), Continue below the shell. Install and Enable send {status: 'approved'} and nothing else; an authorize row opens the link the backend minted, with no OAuth RPC of its own; a running install holds its verb with the busy mark; a failed row sends connectors.connect {reconnect: true} on the open operation, the same call the managed card makes. The owner lookup and that call are now shared helpers on connector-tool.tsx rather than a second copy here. ConnectionTargetOutcome loses connected / initiated / failed: those were the renderer reporting state, which it no longer may do. ConnectionActor loses renderer_flow for the same reason. ConnectionOperationTarget gains required_env, the credentials an MCP install is still waiting for; the card renders a field per entry under the pending row and holds Install until every required one has text, so the values travel with the approval instead of through a separate catalog call. (cherry picked from commit 2e42ad19f63e41f274a87199d07eb99a7c995cbe) --- fix(connectors): the toolkit metadata leaves the wire; the vendor logo is derived from the slug Sid cancelled portal PR3 (the toolkit metadata on the list item) on 2026-09-14, so the fields the contract commit typed as required come off the wire: no title, description, iconUrl, authKind or activeConnectionId on the list item, no total on the page, no search or connected query, no title or icon_url on a target snapshot. The list item is exactly what portal #1220 emits. The desktop derives the vendor logo from the toolkit slug instead (`connectorIconUrl`, https://logos.composio.dev/api/{slug}; the gateway slug is the vendor slug, checked for every lead-order pick), rendered as a plain image because the host sends no CORS header. The title stays `connectorTitle(slug)`. The mark ladder is unchanged: glyph, derived vendor icon, favicon, monogram. Everything else in the contract stands: six-state status, optional connectionId on mint results and on CONNECTION_REQUIRED, returnTo and op, the account routes. The contract commit's message still names the metadata; this commit is the correction. --- fix(connectors): an MCP target survives the card's Continue, and the model is not sent to an action that refuses it The review of the MCP backend found eight defects; each one is a test first. - The off-desktop note told the model to confirm with action 'status', which refuses MCP names outright. It now says the authorization finishes in the background and the tools arrive on the next turn. - The card's existence is a property of the session. A missing callback no longer routes a desktop session down the off-desktop path, where the model would be handed a live link. - A second failure of a backend attempt was published with actor 'user'. ``refresh`` takes the actor, so the frame says who produced the text. - Continue on the RPC thread can settle the operation between any read of a target's state and the transition that follows it. A settled operation has a frozen result, so the lost move is dropped; an IllegalTransition no longer escapes into the tool result. The same rule covers a worker whose outcome arrives late and a Try again that arrives after Continue. - Try again on an install carried no credentials, so the second install ran with an empty env. The approved map is kept on the runner (never on the target: target fields are serialised to the model) and reused. - An approval that does not cover a required credential no longer reaches the worker, where ``install_entry``'s prompt would block on stdin forever; the row waits for the card's fields instead. - ``enable`` writes ``mcp_servers`` under the scope and lock the dashboard's toggle route uses, so the two read-modify-write paths in one process cannot drop each other's write. - Several authorize targets start their flows together and share one wait; one wait per target kept the card empty for minutes. - The off-desktop operation is in no session's registry, so it now emits no connection.update. Try again is also refused for a target the transition table cannot move back to 'initiated' (an MCP target has no move out of 'expired') and for an operation that settled during the call. The contract test that froze the Actor enum is replaced by two behaviour tests: no actor but the backend watcher can connect an MCP target, and the card's word never moves one. (cherry picked from commit 081c16412b48667758a77a7e7c29eaf2be6a93dd) --- fix(connectors): the watcher reads one account route per target, and every frame carries its seq The watch loop walked the whole toolkit list once per tick to learn whether one target had connected. That read costs a vendor call per page, cannot tell one account from another, and forced `awaiting_new_attempt`: after a forced reconnect the list still reported the OLD account `active`, so the row had to be disbelieved until it read as something else once. The gateway now serves `GET /v1/connectors/accounts/{connectionId}`, so each pending target reads its own account: the id the mint named, one read per target per tick at 1 Hz (the route's bucket is 180/min per principal), each bounded by the operation's remaining deadline. A 429 parks that one target until its Retry-After passes and leaves the others reading. A 404 is "not yet" until the deadline. A target the mint gave no account for has nothing to read, so it is not read. A forced reconnect watches the new account, which is why `awaiting_new_attempt` and its two tests are gone. `mint` and `run_remote` now name where the browser should come back to (`returnTo`, plus the operation id on a mint), so the vendor's done page can hand the user back to the desktop app that asked instead of stranding them on a web page. Only the desktop registers that URL scheme, so no other surface sends either field. `connection.update` frames were built by re-reading the operation after the lock was released, so a second writer could give an older frame a newer state and the renderer could not tell which frame was last. Every write now advances a monotonic `seq` and takes its snapshot under the same lock, and the emitter sends that snapshot; a renderer that keeps the highest seq per operation can drop a frame that arrives out of order. `connectors.operation.wake` lets the desktop's deep-link return ask for a read now instead of at the next tick; it only shortens the wait and trusts nothing else in the link. (cherry picked from commit f5423cf72302b92b26c043495184ad6426fa2b36) --- fix(connectors): the desktop card follows the operation, and says so out loud The MCP card was a second implementation of the connector card with the review's defects: it painted for any request on the session, kept its controls after the operation settled, offered an approve verb while the backend was still minting an authorize link, and re-enabled Install when the RPC returned rather than when the state frame moved the row. A second click in that window sent the consent twice. The renderer now reads the operation's `seq`: an update or a status frame whose sequence is not greater than the one already applied changes nothing, and a resume snapshot neither revives a settled card nor puts back a row a newer frame has moved. Without it the transport's ordering decided what the user saw. `hermes://connections/done?op=…` brings the user back from the browser to the session that opened the operation and wakes its watcher, so the row moves at once instead of at the watcher's next tick. Only the op id is used; the link's status moves no row. Each row's mark and cue are one polite live region, so a row that flips is heard and not only seen, focus follows the row the backend moved while the card holds it, and the waiting mark stops spinning under reduced motion. (cherry picked from commit 7c30d252556d7d496ddb354b50bcecc41bceef27) --- fix(connectors): the renderer types seq as the wire carries it The watcher commit made `seq` a required field on every operation frame. The desktop store still declared its own optional `seq` so it would compile against a backend that predates the field; that backend no longer exists on this branch, so the hedge is dead code and the fixtures were short one field. The store now reads `seq` from the shared types, and the fixtures count the way the backend does. The repeat-frame test asserted the whole request keeps its reference. With a real rising `seq` the request must change; the invariant the test guards is that the target row keeps its identity so open credential inputs do not remount. --- fix(connectors): a URL that arrives after the shared wait still lands on its row The shared prepare wait failed every row still pending when it ran out, while that row's own thread was still waiting on the provider. When the URL arrived a moment later the thread's move raised inside the daemon thread, the link was lost, and Try again started a second flow. The wait now bounds only how long prepare blocks; a row still pending afterwards is left to its own thread, which is the only writer of that row and ends with the URL or the flow's own failure. The comment on the approved credentials said every target field is serialised to the model; it is not (the snapshot names its keys). The reason they live on the runner is that they are secrets and the runner's life is exactly the operation's. --- fix(connectors): the review findings the operation must survive before the fold The MCP prepare threads and the install worker started with an empty context, so a named-profile turn's home override never reached them: the flow resolved the process home's `mcp_servers` and stored the token there. Each thread now runs in a copy of the calling thread's context. `connection.respond` had the same gap on the RPC thread: an approval ran the enable, which writes config.yaml, with no profile bound, so the flag landed in the launch home. The handler binds the session record's profile the way `_connector_rpc` does; `config_write_scope(None)` keeps that override, so the enable needs no change. The watcher raised out of the tool when a per-target Skip landed while that target's read was in flight: the operation stayed open with `live` closed, and every later answer got 4004. A read for a row that is no longer live is dropped at debug; only a refusal on a live row is still a contract violation. The same skip from the card raced a row the backend had just connected and aborted the rest of the answer; a skip for a resolved row is ignored and every entry, then the settle check, still runs. A read was bounded by the whole remaining deadline, so a hung gateway held the first read for 300 s and Continue could not return the tool; a read now waits ten seconds at most. A 429 parked only the target that read, but the budget is the principal's, so the next target's read in the same tick spent it again: every live target waits out the one Retry-After. The MCP surface rule read the platform alone, so a desktop call without the callback (registry dispatch from execute_code) opened an operation nobody rendered and blocked for the deadline; it now uses the managed rule, surface and callback. A write after settlement advanced `seq` while emitting the frozen frame, so the resume snapshot named a seq no frame carried; the counter stops at the settle frame. A mint that reports `initiated` with no account id logs that the watcher cannot read the row. (cherry picked from commit 587b228016bf8ee2b022e7fa58c2d9f6057809e9) --- fix(connectors): the desktop card holds a verb until the backend answers, and never takes the keyboard from a credential field The review of the desktop card found five defects; each one is a test first. - A resume snapshot was refused whenever the cache held a settled operation, whichever operation it was, so a session that opened a second operation after settling the first never got its card back from a resume. And the refused snapshot handed the caller the settled cache as "the request", so the session was flagged as needing input behind a summary with no controls. Only the same operation can refuse the snapshot now, and a refused one is no pending card. - The focus handoff picked the row's first button, which after pending -> initiated is the disabled working verb; the focus call was a no-op and the keyboard landed on the document body. It picks the first control that can take focus, else the row. It also moved focus out of a credential field the user was typing in whenever another row moved; it leaves an editable alone. The "focus Continue once every row resolved" branch was dead (Continue unmounts the moment nothing is unresolved), so it and its ref plumbing are gone. - The done link navigated to a settled operation's session and rejected when the wake RPC did (4004 once the operation left the live registry). A settled request is ignored, and a refused wake is nothing: the wake only shortens the wait, the watcher still ticks. - Install spun forever when the store refused to send the consent (the operation gone or settled under the card): `respondToConnectionRequest` resolves false in that case and the verb was only released in `catch`. - After a partial approval (a required credential missing) the backend answers with a same-state frame whose detail names what is missing; nothing released the verb because it was held until the row's state moved. The row now remembers the seq the click saw and holds the verb only until a frame past it arrives, which is the backend's word on the click whether or not the row moved. (cherry picked from commit 4c534d6e2af979778d9a2423cf97d717edeaa1a9) --- fix(connectors): a skip that loses the race to the watcher is ignored, not raised The skip guard read the row's state and then moved it; the watcher can connect the row between the two, and the refused move aborted the rest of the card's answer. The refusal itself is now the witness: a move refused for a row that is resolved, or on a settled operation, is the same nothing-to-do as a row resolved earlier. Two recording fakes in the managed tests kept their lists on the class; they now start per instance so a lifted fake cannot share reads between tests. --- fix(connectors): a resume that lands behind a newer live frame still reports the pending card The refused-snapshot branch answered "no pending card" for both reasons it can refuse: the operation settled, or a newer frame already moved a row. Only the first is no card. For the second the live card is still open and blocking the turn, so the caller must keep the session flagged as waiting on it. * test(connectors): defer new connection coverage until implementation settles Remove PR-added test cases and their unused helpers while retaining existing tests adapted to the changed connection contract. The three PR-only renderer test files are removed for now. Focused behavioral coverage will be added as the final implementation step before verification. Existing main coverage is not being removed wholesale, and this does not declare the feature merge-ready. * fix(connectors): commit MCP authorization at initialize, save setup values after success The OAuth probe treated one exception as one outcome: any failure after the browser step restored the token snapshot and manager entry, so a server that accepted the token but failed tools/list discarded a completed consent. Now the probe reports whether initialize succeeded (details["initialized"], read from the claimed MCPServerTask). Failure before that point rolls back as before. Failure after it saves the server config, keeps the tokens, and reports tools unavailable through flow.discovery_error; the card can retry discovery without repeating consent. Catalog install wrote the submitted values to .env before install_entry and the probe ran. The values now live in the secret scope for the duration of the install (get_env_value reads through get_secret, so install_entry finds them without a prompt), and .env is written only after the probe returns tools. A failed probe removes the server block and writes nothing. _probe_tool_names returns None on a failed probe instead of an empty list, so failure and a valid empty listing are distinct. Failure text is redacted before it reaches target detail: every value the card submitted for that target is replaced by exact match, then the pattern redactor runs. required_env now carries the manifest's secret and default flags; Target carries the manifest's post_install text as instructions. The wire contract gains secret, default, instructions and discovery_error; generated TS and OpenRPC regenerated. * fix(connectors): one OAuth callback receiver picker for the connection card The card's authorize target built its redirect from the dashboard web server and raised when none was bound in the process, so a standalone hermes --tui session could never authorize an MCP server. The receiver is now chosen in one place (choose_callback_receiver): a pinned pre-registered client keeps the SDK's own listener on the registered port; a client-advertised loopback URI is used as-is and its callback arrives through the mcp.servers.oauth.callback relay; otherwise the backend binds a one-shot loopback listener and feeds it into the flow. The dashboard route stays with the dashboard web page, which cannot bind a port. tui_gateway/mcp_oauth_sessions.py had a second copy of the loopback listener and a _worker that referenced _probe_with_rollback, set_hermes_home_override, reset_hermes_home_override and Path without importing them, so every RPC-started flow raised NameError. Both are deleted; start_flow spawns run_worker directly and uses the same receiver picker. Flow registration is shared (register_flow / finish_flow) so a card-started flow with a client URI is reachable by the relay. Under an SSH session with no client listener the attempt's detail carries the existing paste-the-redirect instructions. Nothing on the card path opens a browser. * feat(desktop): setup-form modal for MCP connection cards The connection card rendered an MCP server's setup fields inline: every field as a password input, no default value, no instructions. A URL such as the n8n MCP server URL was typed blind, and the manifest's setup text never reached the user. Two components carry the form now. SetupFieldList renders the ordered fields the backend declares (a plain field as text prefilled with the manifest default, a secret field masked and empty). SetupFormDialog composes it with a one-line title, the manifest instructions, an inline error for a failed attempt, and Cancel / Connect. The row's Install action opens the dialog when the target has fields; Connect sends {status: approved, env}; Cancel sends {status: skipped}. A failed attempt keeps the dialog open with the draft intact. The draft lives in the dialog component only; nothing reaches the store or the resume snapshot. Once the backend publishes the authorization URL the dialog shows it as text with an Open in browser button. Nothing opens a browser on a state change: the Try again path on both cards used to open the re-minted link at once; it now waits for the row's update frame and the user's click. The store types gain the wire's secret, default, instructions and discoveryError fields and normalise them; a connected target with discoveryError renders as authorized with tools unavailable. * feat(tui): connection card in the Ink TUI The Ink TUI had no client for the connection operation: connection.request, connection.update, connection.respond and the pending_connection resume snapshot were unhandled, so a manage_connections call in a TUI session could only print a link through the model. connectionOperationStore.ts holds the backend snapshot: a request opens only for a new operation id, an update applies only to the live operation with a higher seq, a settled update freezes the id so a late request frame cannot reopen the card. The gateway event handler feeds it; session resume hydrates it from pending_connection. connectionSetupOverlay.tsx renders one callout in the prompt zone: a one-line title, the manifest instructions, every field (plain rows prefilled with the default, secret rows masked), then a Connect / Cancel selector. Connect sends the draft through connection.respond; Cancel skips the active target. When the backend publishes the authorization URL the callout shows it as text under "Press Enter to open in browser"; Enter is the only thing that opens it. A failed attempt unlocks the fields with the draft kept. An accepted secret renders as "Set" and is never echoed. A target authorized without tools shows that state and Continue. The overlay joins the existing input-owner set in overlayStore so typing and other prompts are blocked while it is up. * feat(cli): connection panel in the classic CLI The classic hermes CLI passed no connection_callback, so a manage_connections call could only print an authorization link through the model and could not take a setup value at all. The CLI now renders the connection operation as a prompt_toolkit panel, on the same queue mechanism as the clarify panel: the agent thread's callback opens the panel, blocks until the first decision, then returns so the operation's watch loop runs; every later state reaches the panel through ConnectionOperation.on_change (installed only when no gateway hook is set, restored on close). Panel: one-line title, the manifest instructions, one row per field (plain rows prefilled with the default, secret rows masked in the input buffer and rendered as "Set" once accepted), then Connect / Cancel. Connect sends the draft through apply_answer; Esc skips the active target; Ctrl-C sets the tool-thread interrupt so the operation settles as interrupted. Once the backend publishes the authorization URL the panel shows it with the target detail and "Press Enter to open in browser"; Enter is the only thing that opens it. A failed attempt unlocks the fields with the draft kept; an authorized target without tools offers Retry discovery / Continue. Up/Down move between rows, Left/Right toggle the action, and the panel joins the blocking-overlay guards so chat input, history and voice stay out while it is up. The single-query (headless) mode passes no callback, as it does for clarify. * feat(connectors): register a connected MCP server and report its tools in the result After a successful install or authorization the target carried the probe's tool names and the model was told the tools "become available on your next turn". MCP tool schemas are deferrable by construction, so nothing about them lives in the sent tool array; a server registered in the scoped registry is callable through tool_describe/tool_call in the same turn. The operation now registers the server (register_mcp_servers under the owner's home scope) once authorization is committed, records the registered names on the target, and the settled result carries a tools_listing block in the deferred-catalog format plus a note that the tools are callable now. A registration failure keeps the target connected with tools: [] and a sanitized discovery_error. agent.tools and the system prompt are untouched; the between-turns refresh updates the catalog block as before. The card gate no longer asks for the desktop platform. Every surface that renders the card attaches a connection callback (Desktop, the Ink TUI, the classic CLI); registry dispatch and messaging sessions attach none and keep the link result. Pre-commit rollback in probe_with_rollback used restore(only_if_absent=True), which skips the rollback when a token file exists. On a first-ever authorization the only file is the one this attempt wrote, so a token the resource rejected was kept. Live E2E (controlled provider answering 403 to the issued token) showed the row fail and the token survive; the rollback now restores the snapshot outright, and the same run shows the token file removed. * fix(connectors): install an OAuth catalog entry through the card's own flow The card's install ran install_entry and then a plain probe. For an OAuth entry that probe has no card flow around it: in the desktop backend it failed at once ("non-interactive environment and no cached tokens"), and in the classic CLI it saw a TTY, opened a browser by itself and drew install_entry's curses tool checklist over the panel. Since a probe failure is now an error, the failed install was rolled back with _remove_mcp_server, and authorize refuses a server that is not configured. A clean home had no path to a connected OAuth entry, which is 55 of the 65 catalog entries. Found by the live three-surface run. An install now builds the entry's configuration in memory (card_install_config: no prompts, no probe, no checklist; a prior tool selection or the manifest's curated filter applies). An OAuth entry starts the same flow authorize uses with that configuration and the setup values in the attempt's secret scope, so the row reaches the URL step, and the configuration and the setup values are saved together when initialize accepts the token. Every other entry is probed in memory and saved after the server answers. A failure writes nothing, so a failed reinstall keeps the previous configuration, and the failed row asks for its fields again so the card can reopen the form over the draft it kept. * fix(agent): make a server connected in this turn callable in this turn tool_describe and tool_call resolve names inside the agent's toolset selection, which is fixed when the agent is built. A server that manage_connections had just registered was therefore "not found" for the rest of the turn whose result calls its tools available, and stayed out of the next turn's catalog too. The live Desktop run showed it: the result listed mcp__fx_oauth_fields__echo and the tool_describe that followed answered not_found. The executor now adds the MCP servers the call connected to the selection. Only the selection changes; agent.tools does not, so the sent tool schema bytes stay the same. A selection of None (every toolset) and the no_mcp sentinel are left alone. * fix(cli): reopen the connection form when a required field is still empty When the backend refuses an answer because a required field is missing it keeps the row pending and names the fields. The panel mapped that frame to its waiting phase, which draws the detail line and nothing else, so the user saw "waiting for FX_API_KEY" with no fields and no buttons until the 300 s deadline. The panel now returns to the form on the first missing field, over the draft it kept. * test(connectors): the no-card path is the one with no callback attached The card gate is "a connection callback is attached" since the classic CLI got its own panel. This test still attached one under platform "cli" and expected no card, so it opened a real operation, waited out the 300 s deadline and failed. It now drives the path that has no card: no callback. * fix(connectors): order a cancel against the commit and stop deleting a working grant Found by the live runs on Desktop, the Ink TUI and the classic CLI. A user's skip did not stop the OAuth attempt. With the worker parked in the token request, the row settled "skipped" and the token was written 33 s later. A skip now cancels the attempt, and one lock orders that cancel against the commit: the attempt is either canceled with the earlier tokens restored, or committed and kept. When the commit won, the skipped row says the authorization was kept. An interrupted turn cancels its attempts the same way. Every attempt began by deleting the saved tokens, so retrying discovery for an authorized server demanded consent again, and a cancel in between left no grant at all. The card's flow now connects with the saved tokens first, with no browser step; only when they do not work does it replace them. The RPC session surface keeps the old behavior because its caller waits for an authorization URL. A second Connect from the form a failed row reopened was dropped without a frame, which left the Desktop dialog with Connect loading and Cancel disabled until the deadline. An approval on a failed or expired row is now a retry with the new values. The reported tool names came from the registration call, which returns nothing for a server the process already holds. A retry after a failed listing therefore said "no tools" while the server had them. The names are read from the registry, and a parked server is woken first. An authorization that commits after its card closed by deadline was never registered, so the next turn still could not reach it. The runner keeps such attempts, and the between-turns refresh adopts the ones that were approved. An error with no message reached the user as a class name ("CancelledError"). The tool description still said a server's tools arrive on the next turn. * fix(desktop): let an OAuth install open its link, and keep the form's draft An install of an OAuth catalog entry with no setup fields reached the URL step and gave the user nothing to click: an initiated install was always drawn as a disabled spinner, and the only other place the link is shown is the setup dialog, which opens for entries with fields. That is most of the catalog. An initiated row that carries a link now offers Open, whatever the action. The setup dialog reset its draft whenever the field list changed identity. The backend sends a fresh list with every frame and an empty one while an attempt runs, so a failed Connect erased what the user had typed. Fields now only fill in what the draft lacks, and closing the dialog drops the draft. The settled summary dropped the "tools unavailable" fact, and the live row offered a Try again for that state which the gateway refuses for a connected target. The summary keeps the fact and the row offers no dead control. * fix(tui): keep the typed draft when a Connect fails The overlay reset its draft whenever required_env changed identity, and every backend snapshot delivers a freshly parsed array. A failed Connect therefore came back as a form with the default region and an empty secret. The draft now resets per target only, and a snapshot's fields fill in what the draft lacks. * fix(cli): show the URL step and start an install that has no fields The panel applied the user's answer and then set its phase to "waiting". The backend applies the answer on the same thread and its change hook had already set the next phase, so the URL step of an OAuth install and the reopened form for a missing field were both overwritten, and the card sat on "Waiting…" until the deadline. The waiting phase is now set before the answer is applied. A pending install or enable with no fields opened in the waiting phase, which sends no approval, so the flow never started. It now opens on Connect/Cancel. A target that already carries its link opens on the URL step. Connect on a failed row re-ran the attempt without the values now in the draft; it sends them. The authorized-without-tools phase offered a "Retry discovery" that a connected target cannot run inside the same operation; it offers Continue. * fix(connectors): a newer OAuth attempt replaces the older one for the same server A card that closed by deadline leaves its worker waiting on the browser for up to 300 s, and a tampered callback leaves one waiting too. A retry or a new operation for the same server then ran beside it: both wrote the same token files, and the older one's rollback could write over the newer attempt's grant. The newest attempt per home and server is recorded. Starting one cancels the older attempt, takes over its pre-attempt snapshot so a later failure still restores the state from before either, and the older attempt's rollback leaves the files alone. * fix(desktop): label an install's link control "Open in browser" The control that hands an install's authorization link to the browser reused the action's verb, so the row showed "Install" before the click and "Install" again at the link step, told apart only by the cue. It now reads "Open in browser", the label the setup dialog already uses for the same act. Authorize keeps its verb. * docs(mcp): describe the setup card on the desktop, the terminal UI and the CLI The MCP guide said the chat install exists only in the desktop app and that the CLI relays commands. All three surfaces now show the same card: fields, Connect or Cancel, an authorization link the user opens, one save when the server has accepted the token, and tools the agent can call in the same turn. The tools reference gains the result fields (tools, tools_listing, discovery_error) and the no-card behavior of an OAuth install. * fix(cli): keep the layout hook callable without a connection widget The CLI panel commit added connection_widget to _build_tui_layout_children as a required keyword. That method is the documented override point for wrappers, and five existing tests (extension hooks, prompt stash, subagent dock) call it without the new argument, so CI failed with a TypeError. The argument is now optional, like the other widgets added after the hook was published; a missing widget is left out of the layout. The settled tool result also carried the target's setup instructions. Those are the card's text for the user, and a catalog entry's notes can predate this flow ("restart your session so the tools are loaded"), which contradicts a result that says the tools are callable now. The model-facing result drops them; the card payloads keep them. This restores test_connector_local_batches. * fix(connectors): wait for an in-progress registration before reporting a server's tools Found with the real Vercel MCP server. Saving the configuration wakes the config watcher, which starts its own connect for the new server. The operation's registration call then skips the server as "already connecting" and returns at once, so the card settled "connected" with no tools, and the 214 tools were registered three seconds later. With no names in the result the model searched, found the hosted connector of the same vendor and asked the user to connect that instead. The registered names are now read once the registration has finished: while another task is connecting the server the read waits (30 s at most), a parked server is woken once, and a server that finished registering with no tools is still a valid empty list.	2026-09-21 10:04:32 +05:30
treatux	6ae4cb88d5	fix(docs): reference pages name tools the registry never registered ... The shipped tool-surface references still document the pre-consolidation surface: tools-reference.md lists cronjob/todo/process/project_create/ project_list/project_switch/open_preview/close_preview/read_preview/tour/tip (6 uncallable, 5 hidden dispatch-only aliases), and toolsets-reference.md still claims web_search is a member of the browser toolset — membership decacbac3 deliberately removed (#64503) with a regression test. Both rename commits (e16ad33a9, 217ab2f8d) left website/ untouched. Pin the pages to the live registry with a contract test (real discover_builtin_tools()/resolve_toolset queries over the shipped .md data); rename the rows to the registered surface (cronjob_manage, todo_list, process_manage, desktop_project enum, desktop_preview, gui_tour, show_tip) and add the browser row's actual members (browser_vault_*, browser_exec, apply_layout) that the docs never mentioned.	2026-09-20 12:56:25 -07:00
teknium1	19b29df13b	fix: video generation tools no longer let the agent pick the model ... video_generate advertised an optional `model` argument (and the xAI edit/extend tools a model override) so the LLM could route a single call to a different model family — a different endpoint and billing tier — than the one the user selected in `hermes tools`. image_generate never exposed this, and #83080 asked to extend it there; the ruling is the opposite: models do not choose models. The `model` property is gone from the static and dynamic video_generate schema and from xai_video_edit / xai_video_extend; a `model` smuggled into the call is ignored and the configured `video_gen.model` (then the provider default) is what reaches the request. Config-side selection (`video_gen.model`, `video_gen.<provider>.model`, `<PROVIDER>_VIDEO_MODEL`) is unchanged, and the xAI plugin's explicit-model branch is no longer reachable from the tool layer. Refs #83080	2026-09-19 12:22:44 -07:00
teknium1	2fbcd8b0ea	docs(website): link pages by relative Markdown path so they open on GitHub (#114428) ... Mechanical `check_doc_links.py --fix` pass over website/docs (hand-authored and generated pages) and the zh-Hans mirror: 1,868 route-style links (`](/section/page#anchor)`, `](/docs/...)`) become `](../section/page.md#anchor)`. Every target was asserted to exist on disk; anchors and query strings are preserved; fenced code blocks and inline-code examples are untouched. Two dead targets found by the converter were fixed by hand first: memory-providers.md linked `/user-guide/plugins` (page is `user-guide/features/plugins`), and the zh-Hans learning-path still linked the removed `rl-training` page — ported the EN treatment (external Atropos link). Docusaurus build after: EN locale 0 unresolved Markdown links, 0 broken links, 0 broken anchors.	2026-09-18 14:27:04 -07:00
teknium1	98b4efbf48	fix: clarify cards that cannot render are re-asked as plain text, never reported as user inactivity ... A native clarify card on a messaging platform (Telegram inline keyboard, Slack blocks) could fail without the user ever seeing a question, and the agent then waited out the full clarify_timeout and reported "[user did not respond within Nm]" (#112684): - the platform rejects the card at once -> the wait aborted with a delivery sentinel but the question was never re-asked; - the send outruns the 15 s acknowledgement window and only then fails (pool/connect timeouts, a stale-thread retry) -> the runner never looked at the send future again and blocked for the whole timeout for a card that never posted; - no status adapter at all -> _ask_clarify_question returned ('', False), so a batch reported timed_out=True with an empty notice. gateway/run_turn_runner_clarify_delivery.py (new topical sibling; the send-disposition helpers move out of the gateway/run.py facade) now retries every definitive card failure once through the adapter's plain-text send_clarify (numbered list + text capture) - except a connector egress DECLINE, where re-sending the text is the exfiltration the guard exists to stop - and watches a possibly-delivered send so a late failure releases the waiter with "[clarify prompt could not be delivered]". The no-surface case reports "[clarify prompt could not be delivered: no chat surface]" (same prefix every consumer already treats as a non-answer). Live probe (real TurnRunner + real clarify_gateway, Telegram-shaped adapter, timeout 30 s): card fails after 16 s -> before 45.2 s and "[user did not respond within 0m]", after 16.7 s and the typed answer to the text prompt; card rejected at once -> before sentinel with no text prompt, after the numbered prompt is sent and "2" resolves to the choice.	2026-09-17 09:06:17 -07:00
teknium1	b3aef45987	fix(clarify): batch result carries the surface's no-answer notice; trim tests ... Follow-up to the #112725 salvage. When a gateway clarify batch stops at an unanswered question, the batch payload only said `timed_out: true` with blank answers — so a card the platform REJECTED ("[clarify prompt could not be delivered]") read exactly like a user who walked away, which is the misreport #112684 describes ("a timeout must not be presented as user inactivity when the prompt was never delivered"). - gateway/run_turn_runner.py::_clarify_batch_sync: the unanswered question's own response text rides along as `notice`. - tools/clarify_tool.py::_run_batch/_batch_result: pass `notice` through into the result JSON beside `timed_out` (only when present); schema description mentions it. CLI/TUI batch callbacks send no notice -> byte-identical output. - tests: fold the single-question re-arm pin into the existing bracket-answer test (<=2 new tests), parametrize the end-to-end test over an undeliverable Telegram-shaped adapter so the delivery sentinel is pinned as `notice`. - docs: tools-reference.md describes `notice`. Part of #112684	2026-09-16 17:47:50 -07:00
teknium1	ac63d0eea5	fix(agent): execution guidance and browser hints drop the web_search stripper; tests assert the invariant ... The rebased guidance text no longer names web_search anywhere, so execution_guidance_text()'s replace() calls (3733e4aff5) matched nothing and were dead; the function now returns the neutral text for every toolset and its phantom-tool test asserts "no web tool named" instead of the removed sentence. model_tools ports the PR's hint layer into main's _DYNAMIC_SCHEMA_REWRITERS table (browser_navigate + browser_cdp) rather than a second pass after it. Tests: the two browser_cdp registry tests were re-added by the PR but main pruned them in 39975613b13b4; replaced with one schema-neutrality invariant. Exact-wording assertions ("lightweight retrieval tool", "appropriate permitted retrieval/search tool") were change detectors and are dropped. tools-reference.md row updated to the new schema text.	2026-09-15 04:13:13 -07:00
Teknium	e819846b10	Inspired by Amp: relative time bounds (7d/24h/2w) + wrapper forwarding for session_search after/before ... Amp's thread feed supports relative time filters (`after:7d`, `updated_before:7d`) alongside ISO dates. Extend the salvaged after/before bounds (PR #86067 by @Moodtuner997) the same way: - `_parse_iso_bound()` now accepts relative durations `Nh`/`Nd`/`Nw` (case-insensitive) meaning "now minus N", alongside ISO dates/datetimes. Clearer error message names both accepted forms. - Forward after/before/exclude_session_ids through the public `session_search()` wrapper (the PR predates the wrapper/impl split; without this the SQL bounds were unreachable from the registry handler — same class as the earlier `detail` forwarding fix). Appended after `detail` to preserve positional compatibility. - Tool schema descriptions teach both forms. - Tests: relative after/before against the discovery shape, unit checks for h/d/w math, case-insensitivity, and bad-unit rejection. - Docs: tools-reference row mentions time bounds + exclude_session_ids.	2026-09-15 03:58:05 -07:00
teknium1	4613f895ab	test: give the rewrite-hint fixtures a read baseline; align docs row with schema ... The stale-write guard now refuses write_file on an existing file the task never read in full, so test_write_file_rewrite_hint's overwrite-without-read fixtures were refused before the hint could be computed. Reading first is the exact read->whole-file-rewrite pattern the hint exists for. tools-reference.md's write_file row now mirrors the WRITE_FILE_SCHEMA description (one-sentence contract + the recovery step) instead of a longer paraphrase.	2026-09-15 03:57:24 -07:00
Teknium	6569651b87	fix: harden salvage of #65605 — redaction-gated test, sibling test baseline, docs ... - test_file_staleness redacted-read case now force-enables redaction (matches tests/agent/test_redact.py convention) so it exercises the sentinel path in hermetic CI where security.redact_secrets is unset. - test_write_verification CRLF case establishes a read baseline first (the new guard refuses unread existing-file overwrites by design). - tools-reference.md documents the read-before-overwrite contract. - contributors/emails mapping for DanSpicyTaco.	2026-09-15 03:57:24 -07:00
Siddharth Balyan	cf35e7351e	fix(connectors): manage_connections is absent for accounts the portal has not enabled (#111238) ... A signed-in, paid Nous account that the portal had not enabled for connectors got `manage_connections` in its schema and a raw "tool gateway request failed with status 404" back from every call. The gateway answers 404 for any such account by design, and Hermes gated the tool on paid access or a free tool pool, which says nothing about that. The gate now reads the portal's own answer: a `managed_tools` token claim, plus the existing free-tier leg. The gate is also the tool's check_fn, so a session without the claim never sees the tool and the model has no 404 to narrate. A token without the claim reads as not enabled.	2026-09-14 22:01:32 +00:00
Siddharth Balyan	ee2f5629b8	Desktop connect runs on the connection operation: one card, no link to the model, no renderer polling (NS-868) (#110574) ... * refactor(connectors): cut comments that restate the code Connector modules (tools/connectors, tui_gateway connector RPCs, desktop connector card/store) keep only comments that carry a non-derivable why or a cross-module contract. No behaviour change. * feat(connectors): managed connect runs on the connection operation Managed `connect` / `reconnect` mint one ConnectionOperation for every target and, on a desktop session, block the tool turn until the operation settles; the result is per-target outcomes and never carries a connect link. Off the desktop the result carries the links and returns at once (PR3 delivers them as their own message). Why: the previous leg handed the model a URL and a `wait` verb, and the renderer ran its own 2s poller on top of the backend's 5s one; both walked the whole gateway catalog at two vendor calls per page to read one row (~3 Composio calls/s per pending target). A hidden composer message started the model's `wait` on the user's behalf. None of it was observable from the operation the MCP leg already used. What the operation looks like now: - `contract.py`: TargetState / Actor / SettleReason enums and the `(kind, from) -> {to: actor}` transition table. `operation.transition()` enforces it; a card cannot claim a managed target `connected`, only the backend watcher can. - `live.py`: one open operation per session, found by `op_id`. `connectors.operation.status` reads it, `connection.respond` drives it, `pending_connection` on resume replays it. - `run.py`: the one lifecycle for both target kinds (prepare -> card -> wake/observe loop -> settle -> result). The managed `observe` hook polls the gateway list once per tick for the whole operation; the exact-status route replaces that call when the gateway ships it. - `connection.update` is emitted on every transition and on settlement; registered in the shared event contract with the operation vocabulary typed on the TS side. - `wait`, `_rendered_links`, `_seen_instructions`, the just-minted bounce and `_clamp_timeout` are deleted. `force` on `reconnect` always reinitiates; plain `reconnect` repairs only what the gateway reports disconnected. - `connections.wait_timeout_seconds` is removed from config defaults, the example and the docs. The deadline is `OPERATION_DEADLINE_SECONDS = 300` in `operation.py`; the key was added on this unmerged train so no migration is needed. - Wire model: `statusReason` parsed on connection results; the seven-state `connectionStatus` is typed on list items and an unknown value fails validation; `CONNECTION_REQUIRED` carries `connect_card_available` instead of the link when the session platform is `desktop`. Session platform, not callback presence, decides whether a card exists: the GUI bridge attaches callbacks to every backend session, terminal TUI included. * feat(desktop): connector card subscribes to the connection operation The card renders from the backend's operation instead of driving its own: `connector-flow.ts` (the renderer's 2s `connectors.list` poller, its 120s client deadline and `keepWaiting`) is deleted, and both hidden composer submits in `connector-tool.tsx` go with it. The model is never nudged into a `wait`; the tool call is blocked on the backend until the operation settles. - `connection-request.ts` is the operation store: keyed by `op_id`, one entry per session, `applyOperationStatus` / `applyConnectionUpdate` as pure reducers, `respond` leaves the entry in place (the backend answers with `connection.update`), `ConnectionTargetOutcome` is a discriminated union the backend's transition table accepts. - `input-requests.ts` applies `connection.update`; `connection.expire` and the resume snapshot correlate by `op_id` (a snapshot has no `request_id`). - `ConnectorOffer` renders one `ConnectorCard` per target from a single `Record<ConnectionTargetState, phase>` table; Connect opens the stored link, Try again on failed / expired reissues through `connectors.connect` on the open operation, Not now is a per-target `skipped`, Continue settles. A settled operation renders `ConnectorSummary` rows with no live control. - `tool-render-class.ts`: `manage_connections` renders the card regardless of `HERMES_GUEST_ONBOARDING`; the flag still gates the onboarding flow, not the card. The backend gate already decided admission; a card only exists because the tool was admitted. - `mcp-setup-tool.tsx` speaks the same outcome vocabulary (connected / skipped / failed). - `ConnectorRow.connectionStatus` is the seven-state literal union, not `string | null`. - The guided-onboarding poller (`first-build-connectors.ts`) keeps its own row/phase types and compiles unchanged; PR3 moves it onto the operation. anti-slop: no net-new findings (17 touched files vs 11d1a12472). * fix(connectors): the card never parks the tool thread; every update carries the snapshot Found by the pre-PR adversarial review and a real-path E2E test (both left in the tree). - The desktop `connection_callback` was still `_block("connection.request", ...)`, which parked the tool thread on a private request-id Event until a `_respond` that no longer exists for this event. `connection.respond` settled the operation but the tool waited its full deadline before the watcher loop even started. The callback now only emits the card; the operation's own wake loop is the wait. The MCP leg's blocking bridge goes with it: the card answers through `connection.respond` like every other card. - `connection.request` and every `connection.update` frame carry the full target snapshot (state, link, detail). The initial mint happened before the card existed, so the renderer never saw the links and Connect stayed disabled; a Continue settlement stamped `not_connected` on the backend while the card still showed `initiated`. The store now overlays the snapshot; no state is reconstructed from deltas. - The `connection.update` emitter is a class-level `on_change` slot on the operation, set once by `register()` (a second `register()` no longer stacks wrappers); session lookup takes `_sessions_lock`; a re-minted link on an `initiated` target goes through `refresh_link()` and emits, instead of a bare attribute write. - `session.interrupt` is checked before the first observe, so an interrupted call settles `interrupt`, not `all_resolved`. - A gateway list reporting `expired` for an initiated target is recorded with actor `clock` (the contract's owner of that edge); it raised `IllegalTransition` before. - Dead `keepWaiting` i18n keys from the deleted renderer poller removed. tests/tui_gateway/test_connector_operation_e2e.py runs the desktop lifecycle through the real tool, registry, gateway RPC handlers and callback bridge with only the HTTP client faked. * docs(connectors): prompts and docs describe the operation, not the deleted wait verb The onboarding prompts told the model to call action="wait" with timeout_seconds and to expect a hidden [setup]/[connectors] note; both are gone. tool-search.md and toolsets-reference.md said the model gets a connect link on the desktop. tui_gateway/AGENTS.md gains the connection-operation row of the surface table. * fix(connectors): the panel re-mints only a dead link Try again on a failed or expired target mints a fresh link on the open operation. A waiting target keeps the link it was minted with; the card reopens it and connectors.connect refuses to spend a second mint (LINK_STILL_VALID). The unused refresh_link() goes. The package docstring names the new siblings; the nine-name public surface is unchanged. * test(connectors): the local-batch test answers the operation the way the card does The callback stopped returning an answer in f782b26d98 (the card answers through connection.respond); this test still returned one and waited out the 300s deadline in CI. * ci: retrigger * fix(connectors): the desktop card appears outside guided onboarding Live on a signed-in macOS desktop, the two-app connect never showed a card. Three defects, each hidden by a test that bound state the running app never binds. The backend read the surface from HERMES_SESSION_PLATFORM only. The desktop and TUI gateway bind it as HERMES_SESSION_SOURCE (_set_session_context), so session_platform() was "" and managed connects took the off-desktop branch: links in the model's message, no operation. session_platform() now reads platform, then source. The E2E test binds through server._set_session_context instead of set_session_vars(platform="desktop"). The renderer routed manage_connections to the card only under isOnboardingEnabled(), the HERMES_GUEST_ONBOARDING launch flag, in message-parts.tsx and the run splitter in fallback.tsx. tool-render-class.ts had already dropped that gate in this PR; the two routers had not. Both now route on the tool name alone. ConnectorTool resolved the session owner by the runtime id. Owner routes, hints and session rows are keyed by the stored id, so in registry topology the owner never resolved and the card rendered null while the tool blocked. It now resolves by the stored id, matching the PR1.5 card and every other owner lookup. message-parts-connectors.test.tsx mounts the real Fallback router with the onboarding flag off and distinct runtime/stored ids; red before each renderer fix, green after. * style(connectors): shorter comments, no module mock in the card router test The router test mocked isOnboardingEnabled to false; jsdom has no preload bridge, so the real function already returns false. Comments that restated the code are cut to one line. anti-slop: no net-new findings (25 touched files) * fix(connectors): Connect on a waiting row opens the stored link ConnectorCard derived the button's loading state from the phase label, so a managed row that read "Finish connecting in your browser" (every row, since links are minted up front) had a disabled Connect button. Nothing on the desktop could open the sign-in link; every managed connect ended skipped, not_connected, or at the deadline. The card now takes `busy` for "the action itself is running" and keeps `phase` as a label. The MCP card passes its in-flight flag; the connector card passes the re-mint wait. Red before: the Connect button on an initiated row rendered disabled and a click opened nothing. * fix(connectors): a settled card stays dead; the card binds to its tool call only A second connect for the same apps revived the finished card on the old tool row. The connection.request payload carried no id, so the renderer fell back to matching rows by connector names, and any row with those names qualified, settled or not. The operation now records the model's tool_call_id and sends it in connection.request and in the resume snapshot. The card binds to the tool row with that id and to nothing else; the name-match fallback is deleted. A payload without the id is rejected by the store. `reason` is removed from the tool: it was the only text the card ever showed from the model and its absence forked a second tool part, since `reason` doubled as the row-correlation key in tool-parts.ts. The card never needed it. `connection.expire` is deleted from the contract and from _EXPIRING_REQUESTS: the card is raised with _emit, not _block, so nothing has emitted it since the operation lifecycle landed. Sid's rule of record: a resolved card is fully dead; no path brings it back. * fix(connectors): the watch loop settles once, on time, and never raises into the result Three findings from the live review, one loop. Continue racing a finished sign-in: the loop ran the gateway read, then settled. A read that returned `connected` for an already-settled or failed target raised IllegalTransition out of the tool and the model got a generic error instead of the per-app outcomes. The read now skips targets that are not live (pending, initiated) and skips a settled operation; the loop checks `settled` after every read. Settle reason as row text: `settle()` wrote `continue`/`deadline` into each unresolved target's `detail`, and the card printed it in red. The reason stays on the operation only. Stop and the deadline waited for the next tick: `/stop` sets a per-thread flag with no wake hook, so the sleep is sliced at 250 ms and the flag and clock are read each slice. The clock is also checked before each read, not only after. Tests: a failed mint that later reads connected settles cleanly; Continue during a read keeps the settled result; no reason in detail; an interrupt settles within the same second. * fix(connectors): MCP setup off the desktop returns unavailable instead of blocking run_mcp_operation treated a non-None connection_callback as "a card exists". Every tui_gateway session has that callback, the Ink TUI included, so an MCP install from the terminal UI blocked until the 300 s deadline while the docs promised `unavailable` with the terminal commands. The MCP path now reads the session surface the same way the managed path does; the callback is never the predicate. Test binds the surface to `tui` with the callback attached. * fix(connectors): a failed Try again shows the failure, not the old dead link The panel's re-mint ignored the gateway's per-app status and moved the row to `initiated` with whatever link came back, `None` included, so a mint that failed again rendered as waiting on the link that had already died. One reader of a mint response now serves both the first mint and Try again (`managed.mint`, with the actor as a parameter). A repeated failure keeps the row `failed`, drops the link, and carries the vendor's new text through `operation.refresh`, which emits a frame without a state change so the card redraws. * fix(connectors): a forced reconnect waits for the new sign-in before it reports connected `reconnect` with `force: true` is the account switch. The vendor keeps the old account active while the new link waits, so the first list read after the mint said `connected` and the operation settled at once: the new link was dropped and the model was told the switch was done. A forced target is marked awaiting_new_attempt after the mint. The watcher ignores its row until the list shows the new attempt (`connectionStatus: initiated`) once, then trusts `connected`. * fix(connectors): the operation registers under the gateway session key The tool registered the operation under the agent's session_id; every RPC (connection.respond, connectors.operation.status, the panel's connectors.connect) and the update emitter looked it up by the gateway's session key. Those agree until compaction rotates the agent id mid-turn; then the card's clicks find nothing, no update reaches it, and the tool waits out the deadline. The registration key is now the bound HERMES_SESSION_KEY, with the agent id as the fallback for callers with no gateway (unit tests, a bare CLI). The E2E passes a rotated agent id and drives the card by the gateway key. * fix(connectors): the forced-reconnect gate reads any non-active row; a failed re-mint of an expired row is failed Three follow-ups from the verification of the fix pass. The awaiting_new_attempt gate cleared only on the literal `connectionStatus: initiated`. The field is optional on the wire and `initializing`, `failed`, `expired` are valid values, so a forced reconnect could wait the full 300 s and swallow a failed new attempt. The gate now holds only while the row still reads as the old account (`connected` or `active`) and releases on anything else. Try again on an `expired` row whose re-mint fails raised IllegalTransition (no expired → failed edge). The re-mint steps through `initiated` as the user's attempt, then `failed`, then drops the dead link. `detail` never carries a state name any more: `failed` as detail rendered as the row label and made agent/display.py tag the settled result as a tool error. Only vendor text goes there. `connection.expire` removed from the renderer's unscoped-stream set; nothing emits it.	2026-09-15 00:41:14 +05:30
Siddharth Balyan	e0ef0eb9c3	manage_connections covers local MCP servers; setup_mcp leaves the schema (NS-867, PR1) (#109517) ... * feat(connections): manage_connections covers local MCP servers; setup_mcp leaves the schema One model tool now connects the user to apps of both kinds. A target `{"name": "linear", "mcp": true}` is a locally configured MCP server; `install` / `enable` / `authorize` are its verbs. Bare strings and `{"name": ...}` stay managed connectors and that leg is unchanged. MCP targets run through one backend-owned connection operation (tools/connections_tool_operation.py): created with a server-side deadline from the new config key `connections.wait_timeout_seconds` (default 120, floor 5, no ceiling), per-target state, and exactly-once settlement (all resolved / Continue / deadline / interrupt). Unresolved targets freeze as `not_connected` with the settle reason. Why the fold works now: the approval card is reached through `agent.connection_callback` via the agent-level inline executor table, which is the only path that carries a GUI callback. Registry dispatch (every non-GUI surface) settles MCP targets as `unavailable` with the `hermes mcp install / login` hint; managed targets in the same call are unaffected. `setup_mcp` is removed from every advertised toolset and from the deferral list; an inline-table shim keeps calls from conversations opened before this change dispatching (prompt-cache protection). `_LEGACY_TOOL_ALIASES` is not the mechanism: inline tools bypass it. Gateway: `mcp.setup.request/respond` are replaced by `connection.request/respond/expire` (no wire compat; desktop ships with this). The bridge waits exactly the operation's deadline. The `session.resume` snapshot gains `pending_connection` so a reopened window restores the card with the original deadline. `manage_connections` joins `_SEQUENTIAL_DEADLINE_EXEMPT_TOOLS`: the operation owns its wait; the 420s guard must not report `tool_timeout` while the card is live. The portal `check_fn` on the tool is dropped in favour of a handler-level gate on the managed leg, so signed-out sessions can still approve local MCPs. * wip(desktop): connection.request store, resume restore, card routing for MCP targets Renderer half of the setup_mcp fold, first slice: connection-request store (mirrors clarify), connection.request/expire handling, pending_connection resume restore, mcpTargets() + isCardTool(name, args) so MCP-target manage_connections calls classify as cards. Not yet: the card component rewrite (mcp-setup-tool.tsx), mcp-directory.ts removal, vitest, docs. Does not typecheck until the card rewrite lands. * fix(config): hermes update turns on the connections toolset for saved toolset lists `hermes tools` writes an explicit `platform_toolsets.<platform>` list, and the resolver reads absence from that list as "unchecked". The `connections` toolset (#106842) shipped after most users last saved, so `manage_connections` is stripped from the schema on every install that ever opened the picker. The Nous entitlement gate never runs; the agent reports the tool as missing. Migration 44 -> 45 (renumbered when folded into #109517; main was already at 44) appends `connections` to each explicit per-platform list that lacks it and records the offer in `known_builtin_toolsets` where that record exists, so a later uncheck reads as a decline. It skips: platforms whose record already holds `connections` (the user saw the checkbox and left it off), bare composite lists ([hermes-cli]) that already inherit it, platforms where the toolset is not allowed, and any config whose `agent.disabled_toolsets` names `connections` (Blank Slate, `hermes tools --disable`), because the resolver subtracts that list last and the enable would never take effect. The explicit-list test is the resolver's own: any configurable or plugin key. `hermes update` runs migrations post-pull for the active profile and every sibling, so one update is enough. Fresh installs and composite users were never affected. * refactor: anti-slop pass on the desktop slice; shorten added comments Parse connection.request at the boundary with a typed wire interface instead of unknown + typeof; mcpTargets reuses connectorText; comments cut to one or two lines. slop-ratchet: no net-new findings in 13 touched files. * feat(desktop): the MCP approval card answers manage_connections; MCP Directory removed The existing card (mcp-setup-tool.tsx) now reads the connection-request store, renders for manage_connections calls with mcp:true targets, answers through connection.respond with a per-target outcome, and no longer calls reload.mcp after Install; the new server's tools arrive on the between-turns refresh. A settled operation renders the first target's frozen state. session.resume restores a pending card with its original deadline on both the activate and cold-resume paths. lib/mcp-directory.ts is deleted along with its two fallback branches (suggestion provider, card install). The catalog was already primary in both; a catalog miss now yields no suggestion / a notInCatalog error. The GitHub never-suggest test is rewritten on catalog-shaped data. vitest: connection-request store (6), suggestion provider, clarify restore. slop-ratchet: no net-new findings in 19 touched files. * chore: drop __pycache__ files swept in by an over-broad git add * fix(desktop): correlate the connection.request row with the model's tool call by reason The synthetic row from connection.request and the tool.start row carried different ids and no shared match value (op_id is not in the model's args), so the card mounted twice. reason is the arg both sides carry. * docs: manage_connections covers local MCP servers; connections.wait_timeout_seconds * fix(connections): settle reason derives from target state, never from the renderer A card that answers one of two targets and claims all_resolved must settle as continue with the other target not_connected; found live with a two-target call. * fix(desktop): a pending connection card re-arms on resume and activate The store entry was restored but the transcript row was not, so navigating away and back (or reloading) lost the card while the backend kept waiting. restorePendingClarifyToolCall's core is generalized to any blocking tool name and both resume paths project the connection row through it. Verified live: card restored after navigate-away and after a full renderer reload, deadline_at unchanged, approve settles connected. * style: literal wording in added comments, docstrings and docs * fix: shared gateway-event contract and config-schema category for the connection events connection.request/expire replace mcp.setup.* in apps/shared gateway-events (json list, BACKEND_EVENT_NAMES, GatewayEventMap) so the renderer's event union includes them and the tui_gateway contract test passes. The new `connections` config section folds into the agent tab like the other single-field sections. * style: import order (perfectionist) in the desktop and shared files this PR touches * chore: retrigger CI (zero-job dispatch failure, auto-heal)	2026-09-15 00:41:13 +05:30
Teknium	3304d205be	feat(video-gen): Kling 3.0 Standard + Pro families on the FAL backend ... Adds kling-v3 (fal-ai/kling-video/v3/standard/*) and kling-v3-pro (fal-ai/kling-video/v3/pro/*) to FAL_FAMILIES: start_image_url i2v key, aspect_ratio dropped on i2v, string duration 3-15s, generate_audio and negative_prompt real, no seed/resolution keys per the published llms.txt schemas. Payload shapes pinned in tests; docs mention updated.	2026-09-13 21:01:32 -07:00
teknium1	c6f87deb2c	feat(video): OpenRouter backend covers every model on the live video catalog ... The salvaged #103267 plugin hardcoded a single model (minimax/hailuo-3-max) and rejected any other id. OpenRouter's public GET /api/v1/videos/models already publishes every generative model with its supported durations, resolutions, aspect ratios, frame-image support, audio and seed flags, and pricing SKUs, so the provider now reads that catalog (5-min TTL, offline snapshot fallback): - list_models(): all 25+ generative models (edit/upscale/avatar rows that take no duration are outside the unified video_generate surface and are dropped) with a per-second price label where the SKU is per-second - capabilities(): the CONFIGURED model's surface, so the dynamic schema only advertises audio/seed/resolutions the selected model honours - _build_payload(): clamps duration/resolution/aspect ratio to the model's live limits (nearest by value/height/ratio) and drops generate_audio/seed for models that lack them (the API 400s otherwise); reference images ride in input_references; local file inputs are refused (OpenRouter fetches URLs itself), data:image/ URLs from the sandbox chokepoint pass through - bearer key only ever goes to the configured origin (poll + /content), never to a provider-supplied unsigned_urls host (kept from #103267) Also drops the source-grep `_IGNORES_SEED` escape hatch #103267 added to the declaration⇄implementation sweep; the provider now implements seed for real. Docs list OpenRouter and DeepInfra as bundled video backends. Requested by Don Piedro Savastano (Discord): OpenRouter credit for video_generate.	2026-09-12 13:44:52 -07:00
Teknium	77e55b4d1f	fix(desktop): show each in-app tip once, never lap the catalog again ... The idle tip rotation walked the catalog as a ring: after the last tip it wrapped to the first, so a user who had already seen every tip kept getting "Start fresh", "Teach it once", ... again every six hours for as long as they used the app. Only the X stopped a tip, and letting a bubble time out (the normal way it leaves) counted for nothing. The walk is now one lap. nextTip also steps over every tip in the seen ledger ($tipShownAt, which already recorded every catalog tip that reached the screen), so a tip shows once however it left, and the rotation runs dry once every tip has had its moment. Settings > Reset clears the seen ledger and the cursor as well as the retired set, and its button counts what a Reset would actually bring back (shown or closed, counted once). Agent tips carry no catalog id and are untouched. Live repro (Playwright against the worktree's Vite renderer, all nine tips seeded as seen, clock fast-forwarded past settle + cooldown): origin/main re-showed "Start fresh"; fixed renderer shows nothing; a fresh user (nothing seen) still gets the first tip.	2026-09-10 11:18:16 -07:00
Teknium	f1ccf436a2	feat(web): Perplexity Search API as a web_search + web_extract backend ... Adds plugins/web/perplexity — a keyed-only WebSearchProvider over httpx: - search: POST https://api.perplexity.ai/search (documented Search API), search_context_size=low so `snippet` stays description-sized; results[].snippet -> description, max_results capped at the API's 20. - extract: POST /sdk/content/snippets — the query-relevant page-excerpt route behind `pplx content snippets` (the CLI's `content fetch` is deprecated upstream). web_extract has no query, so the URLs' path words serve as the relevance query; per-URL `error` entries survive a 200. - Wired into the same touchpoints as the other keyed vendors: legacy backend set + credential ladder + availability probe (web_tools), registry preference walk, OPTIONAL_ENV_VARS, `hermes config`/status/ dump key lists, nous_subscription direct-credential detection, setup summary, test conftests, docs. Not a keyless-ring member (Perplexity has no anonymous tier). Related closed PRs #9192 / #23981 / #45225 predate the plugin ABC.	2026-09-04 07:17:00 -07:00
Lakshya Agarwal	428e084dcd	feat(web): add Tavily web search and extract provider ... This commit re-introduces the Tavily provider, which supports both search and content extraction capabilities, which was removed in #99199.	2026-09-01 10:56:49 -07:00
Brooklyn Nicholson	b293157f7d	feat(tools): withdraw tip and tour when the user switches them off ... Off should mean the model is never told the tool exists. A switch that only made the call fail leaves Hermes offering walkthroughs it cannot give and promising to point at things it cannot point at, which reads as a broken agent rather than a respected preference. Both gate on the switch through a shared desktop_ui.user_enabled helper, which is the reactions check_fn generalized — same config read, same reason it has to be config rather than an env var: the switch belongs to the session's client, and the client may be on another machine.	2026-08-31 21:11:11 -05:00
Teknium	d6773cf26f	refactor: remove the Tavily web backend; keyless ring is exa/parallel/firecrawl/keenable ... - Tavily plugin deleted (plugins/web/tavily), keyless endpoints and ring entry removed from keyless_mcp, legacy backend set / credential ladder / preference walks / rescue key map scrubbed. - TAVILY_API_KEY deregistered across config, setup, status, dump, and nous_subscription surfaces. The tvly- redaction pattern stays -- legacy keys in user envs still deserve masking. - Sibling test pins migrated (keenable/exa stand in where tavily was the fixture vendor); tavily test suite deleted. - Docs updated: web-search, configuration, integrations, environment-variables, tools-reference, web-dashboard, provider plugin dev guide. Live-verified from an isolated HERMES_HOME with all web creds blanked: zero-config resolution lands in the 4-vendor ring, live keyless ring search succeeds, no tavily anywhere in resolution order.	2026-08-31 00:56:41 -07:00
Teknium	b6bd681e89	feat(todo): nested subtasks via optional parent field ... The todo tool now supports hierarchical task lists: an item's optional 'parent' field points at another item's id, making it a subtask. - tools/todo_tool.py: parent validated (self-ref dropped), dangling refs and cycles sanitized; merge mode can set/clear parent; post-compression injection renders the tree indented and keeps a finished parent visible while any descendant is still active; the in-progress reorder pass is skipped for nested lists (a flat move would tear subtasks from parents). - Schema cost: ~45 tokens added to the cached tool schema (one string property + one behavior sentence). - acp_adapter/tools.py: todo result markdown indents by parent depth. - Desktop: TodoItem carries parent; todoTree() DFS helper; composer status stack renders subtask rows indented (depth-capped), stabilizer compares depth. - Docs: tools-reference todo entry mentions nesting. Hydration/replay paths (gateway fresh-agent, API-server history) work unchanged: parent rides inside the same todos array.	2026-08-29 07:25:12 -07:00
brooklyn!	4bd2793367	feat(desktop): default the in-app tip rotation on (#96831) ... Made opt-in when it fired a tip 45 seconds into a launch and another every six minutes, which is a cadence that owes you a choice. The pacing has since become a settling delay of five to ten minutes per launch and a six-hour cooldown persisted across them — roughly a tip a day, weeks to walk the catalog. At that weight the switch has nothing left to protect anyone from, and a discovery feature nobody meets is one nobody has. The switch stays for whoever still wants it off.	2026-08-28 03:10:46 +00:00
Brooklyn Nicholson	198a69421c	feat(desktop): pace the tip rotation in hours, not minutes ... A first tip 45 seconds in and one every six minutes after walks the whole catalog in an hour, which is the cadence of a notification rather than a nicety. Games get this right by being almost absent: a tip while you settle in, then nothing for the rest of the day. Two clocks now have to agree. A per-launch settling delay of five to ten minutes means opening the app is never met with a bubble, and a six-hour cooldown persisted across launches means quitting and reopening isn't a way to farm them — the old schedule lived in the effect and re-armed on every mount. Flipping the switch on skips the settling delay and offers immediately, since that clock guards a launch you came into with a purpose, not a deliberate opt-in. An agent tip starts the cooldown too: whoever just pointed at something, the user has had their one interruption for a while.	2026-08-27 21:50:18 -05:00
Brooklyn Nicholson	0357982696	feat(desktop): make the idle tip rotation opt-in, ungate the tool ... The two halves of tips were behind one switch, which meant the app volunteering commentary at idle shipped on by default. Split them along the line that matters: the rotation talks unprompted, so it now waits to be asked for, while an agent tip stays ungated like the tour it mirrors — Hermes raises one mid-conversation, in answer to something the user said. Drops the tool's config gate along with the config key it read. The renderer mirrored that key with config.set, which has no branch for it and answered "unknown config key" into a swallowed catch, so the opt-out never reached the backend in the first place.	2026-08-27 21:50:18 -05:00
Brooklyn Nicholson	911c6c50d3	feat(tools): let Hermes point at one thing with the tip tool ... The quiet sibling of `tour`, in the same `desktop_ui` toolset and reading the same `tour(action='targets')` discovery call: one bubble with an arrow, for a sentence that would be clearer with a finger on the thing it's about. Dimming the whole app to say "the model name is a button" is the wrong weight. Fire-and-forget rather than a round-trip, because a tip is not a question and blocking the turn on one would stall the reply it belongs to. The renderer enforces the user's opt-out itself, so a stale config read can never put a bubble on a screen that asked for none.	2026-08-27 21:50:18 -05:00
Brooklyn Nicholson	0fd3b61ea9	feat(desktop): durable element handles, and a delta instead of the whole page ... Every drive_preview action answered with the entire inventory — around 120 elements of ref, role, label, and an up-to-eight-rung `:nth-child` selector chain. On a real app shell that was ~24.5k characters, re-sent after every click, so a ten-step task paid for ten copies of a page that had barely moved. Handles are now durable and legible. An element is named after what it is and what it says — `btn-sign-in`, `inp-email`, `srch-search-projects` — minted once per page and never reused, with duplicates disambiguated as `btn-edit`, `btn-edit-1`. Each one remembers a stable attribute, its role, its accessible name, and the nearest landmark it sits in, so when a framework destroys the node and builds a new one the handle moves across and the agent is told `rebound` rather than being handed a removal it has to react to and an addition it has to re-read. The re-bind ladder is anchortree's (Apache-2.0), minus its geometry rung, which can never clear the threshold on its own. Because the handles hold, the first look at a page returns the inventory and every look after it returns only what moved. `changed` carries the ref and whichever of label/value/disabled actually shifted — role and selector are absent by construction, since a change in either would mean the re-bind ladder was looking at a different element. A delta gives way to a full re-read when half the page is new, where there is nothing left to reuse. The selector column is gone with it. It was 74% of the inventory on an 85-element page, nothing downstream ever read it, and a positional chain is wrong the moment a sibling appears. An `#id` or `[data-testid]` survives when the page offers one; everything else is addressed by handle. Legibility is what makes the delta work rather than a nicety. `+ btn-sign-in` on turn nine reads on its own, where `+ @e42` sends the model back to an inventory twenty thousand tokens ago. Measured on an 85-element app shell: 18,693 -> 4,930 characters for a baseline, and a steady turn that moved two things costs ~200.	2026-08-20 05:26:37 -05:00
Brooklyn Nicholson	c57581cd0d	feat(tools): drive_preview and annotate_preview — the agent can use the page it opened ... The in-app browser was a one-way mirror. open_preview put a page in the pane and read_preview read its text back, but nothing could touch it. A click meant falling back to the browser_* tools, which drive a separate Chromium the user cannot see — so "log into this and pull my invoices" happened in a different browser from the one on screen, with none of the sessions the user is already signed into. Four pieces, and they only make sense together: · an in-page engine that inventories what is interactable and performs the verb, injected as source because it has to run inside the guest page; · the preview.act.request bridge from the gateway into the pane; · drive_preview, for acting: elements, click, type, scroll, press, and the pane's own back/forward/reload; · annotate_preview, for marking without acting. Those last two started as one tool doing two unrelated jobs. Leaving a mark is not an action — it outlives the turn that drew it — so it gets its own verb, and the interaction verb gets a name that says what it does. Gating is the existing surface rule: desktop_ui folds in on session source: 'desktop', and the bridge refuses to act for a background session, so a turn running behind the user's back cannot reach into the page they are working in. Two details worth a reviewer's attention. Typing assigns through the prototype's value setter, because React shadows value with its own accessor and ignores an input event whose value it believes it already wrote — a plain el.value = … types into a field that snaps back on the next render. And clicking replays the pointer/mouse pair before activation, because frameworks bind to mousedown as often as to click.	2026-08-20 05:26:37 -05:00
Brooklyn Nicholson	60e9ed12c4	feat(tools): close_preview so the agent can dismiss the pane it opened ... open_preview and read_preview could drive the page, but nothing could close the pane. Same desktop_ui / session-source gate as the rest of the GUI tools.	2026-08-19 14:59:51 -05:00
Brooklyn Nicholson	bbd6607968	docs(tour): document navigating steps and the handle vocabulary	2026-08-19 00:52:56 -05:00
Brooklyn Nicholson	93b50ea0bb	test+docs(tour): cover the engine and document the API ... Ten behavior tests for target discovery, stable-selector ordering, step paging, recovery hints, and the self-containment contract the preview injection depends on. Docs cover data-tour markup and the curated-tour entry point alongside the tool itself.	2026-08-19 00:52:54 -05:00
ethernet	25c6516607	feat(desktop): single confirm for the batch clarify card ... The batch card previously locked each answer with its own Continue press. Now picks and typed answers stage locally, and one Confirm and continue button (enabled when every question has an answer) submits the whole batch. Staged answers stay editable until that confirm. The wire protocol is unchanged. The confirm sends the per-question locks in sequence, because the last lock resolves the blocked tool and each earlier lock must already be accepted when it lands. Replayed locked answers from a reconnect pre-stage their questions so restored progress stays visible. The TUI and CLI keep incremental per-question locks, so a timeout there still returns partial answers.	2026-08-18 21:28:53 -04:00
ethernet	86a6865e6e	docs: describe multi-question clarify batches per surface	2026-08-18 21:28:53 -04:00
Brooklyn Nicholson	c7a1bfea07	docs: note the clarify recommended-choice ordering in the tools reference	2026-08-13 01:19:42 -05:00
Jakub Wolniewicz	ae23b1f676	fix: complete kanban review lifecycle ... Close the autonomous implement-review-rework loop, preserve parent gating and implementer provenance, distinguish downstream review cards, and surface legacy review dependency deadlocks immediately. Co-authored-by: kaishi00 <6590895+kaishi00@users.noreply.github.com>	2026-08-10 12:43:46 -07:00
Nikita Barkov	16accefd2f	feat(kanban): add first-class "review" handoff lifecycle ... Add a non-terminal "review" status so a worker that finished implementation can hand off for human review without abusing kanban_block. The old kanban_block(reason="review-required: ...") convention routed the handoff through the unblock-loop breaker, so a normal review -> changes -> review cycle was falsely escalated to triage. - kanban_db: request_review (running/ready -> review, non-block, emits review_requested), reopen_review_task (review -> ready/todo, review_reopened), complete_task accepts review -> done, and a review_dispatch gate (default off, shared by the dispatcher loop and the gateway health probe). - kanban_request_review worker tool + `request-review` / `reopen-review` CLI verbs; tool wired through toolsets, EXPOSED_TOOLS, _POLISHED_TOOLS. - Gateway notifier wakes the origin subscriber on review_requested and block_loop_detected; the subscription survives until done/archived, so every review cycle re-notifies. - Dashboard PATCH + bulk route the review transitions (request_review / reopen_review_task) and render the review column. - goals.py goal-loop and KANBAN_GUIDANCE recognize review as a terminator. - Docs (reference tables, user guide, AGENTS.md, zh-Hans mirrors) + tests. needs_input / failed are unchanged: they still route through kanban_block, still count toward block_recurrences, and still escalate to triage.	2026-08-10 12:43:46 -07:00
Brooklyn Nicholson	0c2cdccccc	fix(build): win32 get-windows staging must skip the tarball's bundled darwin binding ... The published tarball ships lib/binding/napi-9-darwin-unknown-arm64 on every platform, so a real Windows host has both it and the downloaded win32 binding — the classify-everything gate threw on the darwin dir and killed every Windows pack. Stage only bindings naming the target platform (classify still rejects impostors), stop copyGlobByExt from recursing into lib/binding, and add a version tripwire so a get-windows bump fails the build until the lib/windows.js rewrite is re-verified. Also from review: the renderer answers window.read.respond with empty text when the IPC invoke rejects (older shell / main-side throw) instead of stalling the tool's 30s timeout; the tool schema discloses that sibling Hermes windows are skipped; docs gain read_window_below in both references.	2026-08-08 12:17:50 -05:00
Brooklyn Nicholson	f88f6f8e67	docs(reference): document the desktop_ui toolset ... The six GUI tools moved out of `terminal` into their own toolset; the tables still described them as check_fn-gated members of it, and as available to every hermes-* platform bundle.	2026-08-06 19:35:47 -06:00
brooklyn!	64646dda56	Hermes can read the in-app browser (#79482) ... * feat(agent): read_preview — the desktop-gated tool that reads the in-app browser The agent could open the preview pane (open_preview) and read the embedded terminal (read_terminal), but the browser it had just opened was a black box — 'what does this page say?' had no answer. read_preview mirrors read_terminal end to end: HERMES_DESKTOP-gated via check_fn (zero schema footprint outside the GUI), dispatched through the same agent callback pattern, windowed with start/count so a long page pages instead of flooding context. * feat(gateway): preview.read blocking bridge Same lifecycle as terminal.read: the tool blocks on preview.read.request, the renderer answers preview.read.respond (allow_expired — a slow page extraction losing the 45s race must not surface a raw 4009), and a timeout emits preview.read.expire so late answers resolve quietly. * feat(desktop): the renderer serializes the active preview tab for the agent preview-reader.ts is the preview analog of the terminal's buffer registry: the URL pane registers a page reader (webview executeJavaScript → title + visible innerText) keyed by tab id; readActivePreview resolves the ACTIVE tab, windows the text (24k cap per read), and answers file/artifact tabs with identity plus a note pointing at the tool that reads that content directly. The gateway event handler answers preview.read.request beside terminal.read.request.	2026-08-05 16:35:00 +00:00
Teknium	4be0d56023	perf(tools): compact delegate_task description by deduping against param schema ... The top-level delegate_task description repeated content the model already receives through parameter descriptions: the concurrency limit (tasks param), the full nesting clause (role param), context-passing guidance (goal/context params), and background semantics (background param). Every API call paid for the duplication (~4,000 chars). The description now carries only what exists nowhere else in the schema: use/don't-use routing (execute_code, cronjob), the no-poll rule, the non-durability warning, the self-report verification contract with concrete verbs, the language-passing example, the leaf blocked-tool list, and model inheritance. 3,963 -> 1,704 chars (~570 tokens saved per API call), and the top-level text is now static (dynamic limits flow only through the two param descriptions, which are already rebuilt per get_definitions() call). A/B benchmark across 4 models (gpt-4o, gpt-4o-mini, claude-haiku-4.5, llama-3.3-70b) showed the naive compaction in PR #72813 regressed weaker models on exactly the passages it cut (side-effect verification 8/8->0/8 on gpt-4o-mini; language passing 3/3->0/3 on haiku-4.5). This version keeps those benchmark-sensitive hooks verbatim. Tests pin the contracts at keyword level (not prose-literal) plus a size ceiling, and verify dynamic limits still reach the model via the tasks/role param descriptions. Refs #72737, supersedes the delegate_task half of PR #72813.	2026-08-02 22:44:58 -07:00
Teknium	43874d1a96	docs: accuracy sweep + coverage for 2 months of shipped features ... Accuracy pass (all 373 pages audited against code, 13 parallel audits): - configuration.md: 12 stale defaults/keys (file-sync rewrite, clarify timeout, streaming knobs, iteration budget, TTS/STT enums) - reference/: commands/env-vars/toolsets/tools synced with COMMAND_REGISTRY, argparse tree, OPTIONAL_ENV_VARS, TOOLSETS (28 env vars added, 3 phantom removed, mcp__ naming, webhook platform restricted toolset) - features/, messaging/, developer-guide/, guides/: ~60 factual fixes (web_extract truncation, dashboard auth fail-closed, delegation blocked tools, adapter signatures, session schema v23, phantom Matrix env vars, hermes setup tts, auth spotify, webhook --skills) - zh-Hans: explicit heading IDs fix 2 broken WSL2 anchors New coverage for features shipped in the last 2 months (verified against code before writing): - compression.in_place, verify-on-stop (+v31/v32 migration reality), ${env:VAR} SecretRef, display.timestamp_format, session:compress hook + thread_id/chat_type fields - /journey learning timeline, per-channel model/system-prompt overrides, /sessions search, clarify multi-select, -z --usage-file, uninstall --dry-run, config get/unset - MCP elicitation, extra_headers, discover_models, api-server run cap, Bedrock cachePoint, Discord reasoning_style, Google Chat clarify cards, vibe reactions, resume cwd restore, Yuanbao forwarded messages, api_content sidecar, roaming pet, tool_progress log mode, WhatsApp polls/locations, kanban per-task model + lifecycle hooks	2026-07-29 08:48:05 -07:00
Julien Talbot	b9b100da11	docs(xai): clarify x_search vs xurl routing without schema cross-refs ... Make the x_search / xurl boundary explicit in the skill, feature docs, toolset metadata, setup note, and reference pages, while keeping the model-facing x_search schema generic (no static xurl name). Regression tests assert behavioral routing invariants rather than frozen prose snapshots. Drop the stale CI-only plugin/hangup hunks already on main so this rebases cleanly.	2026-07-23 21:06:47 -07:00
Gille	f29c28d6d0	docs(kanban): clarify unblock status routing	2026-07-17 15:47:39 -07:00
kocaemre	a710becd6c	docs: fix 25 documentation/code inconsistencies (audit round 3) ... Cross-checked website/docs against the source at main HEAD and corrected documented commands, env vars, config keys, headers, and default values that don't match the code. Docs-only; no behavioral changes. Refs #36048 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-16 04:47:40 -07:00
CrazyBoyM	ecffd290a3	feat(image-gen): support Codex image inputs	2026-07-02 17:12:24 +05:30
Teknium	b31b0b9d95	docs: reconcile docs with code across last 3 releases (#54254) ... Audited the last 3 releases (v2026.5.28..main) against the docs site and fixed code-vs-docs drift: - slash-commands: add /moa, /prompt, /pet, /hatch, /timestamps - cli-commands: add hermes pets / project / desktop / whatsapp-cloud + dashboard register; correct --insecure (now a deprecated no-op); add gateway migrate-legacy + enroll --wake-url + dashboard --skip-build - environment-variables: document the remaining ~48 env vars (SimpleX, Photon, Teams adapter, per-platform *_ALLOW_ALL_USERS, home-channel vars, IRC, Brave/Krea/Notion/Linear/Airtable/Tenor keys, QQ_SANDBOX) — full OPTIONAL_ENV_VARS (265) now covered - configuration: document tool_loop_guardrails, goals, prompt_caching, network, onboarding, dashboard config blocks - toolsets/tools-reference + tools.md: add coding/project toolsets and read_terminal/project_* tools; remove the stale messaging toolset and send_message agent tool (removed in #47856); drop stale RL-training prose - messaging: new IRC channel page (adapter shipped without docs) + index row + sidebar + env vars - pets: document the /hatch AI generation pipeline + Nous/OpenRouter image backend - web-dashboard: document the bearer-token / TokenPrincipal service auth path - purge agent-callable send_message references across guides/features and the research-paper-writing skill (tool removed in #47856) Verified: docusaurus build succeeds; all authored internal links resolve.	2026-06-28 12:47:50 -07:00