mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-17 04:11:35 +00:00
* feat(connectors): the backend serves a connector's tool list, cached for 24 hours
The Connectors page opens one app and shows every tool it has. The backend
had no way to read that list.
- `tools/connectors/portal/`: a client for the portal's tool-list route and a
JSON cache under the Hermes home, one file per portal origin and connector.
An entry is fresh for 24 hours. After that the read revalidates with the
stored ETag: 304 keeps the list, 404 deletes the entry, an upstream failure
serves the stored list marked stale, and a 401 never serves the cache.
- `connectors.tools {slug, refresh}`: account-level, routed by `profile`, no
chat session. Errors carry a fixed `reason` from one closed set on the rail.
- Every connector model that is not operation state moves into
`tui_gateway/contracts/connectors.py`. Handlers that no chat session owns
live in `tui_gateway/methods_connectors_account.py`.
The wire model is tolerant: an unknown facet reads as unclassified and one odd
tool never blanks a connector.
* feat(connectors): catalog, accounts and member tool rules by RPC
The Connectors page needs the app catalog, the connected account of one app,
a way to disconnect it, and the member's own on/off rules. None had an RPC.
- `connectors.catalog`: name, description, category and logo of each app.
- `connectors.accounts`, `connectors.accounts.remove`: read the accounts at
the tool gateway and remove one by id.
- `connectors.policy.get`: the rule layers that apply to the member, widest
first. The body is a union on `mode`, so a reader can name who turned a
tool off.
- `connectors.policy.set`: one change, a union on `type` (the tools of one
connector, or one connector on or off), with the revision the user saw. A
stale revision answers `POLICY_CONFLICT`. The backend composes the upstream
write in one pure function, so no renderer learns the upstream rules.
- Bundled MCP manifests can name their hosted twin with `connector:`, so the
page can show one card per app.
* feat(connectors): connect an app without a chat session
Every connector RPC took a `session_id`, and a connect that did not come from
the model's tool call minted a link with no watcher. The Connectors page has
no chat session, and its card must flip to connected by itself.
- `connectors.list`, `connectors.connect`, `connectors.operation.status`,
`connectors.operation.wake` and `connection.respond` take `owner`, a union
on `type`: `session` (today's behaviour and authorization) or `account`
(routed by `profile`, authorized by the live transport like `mcp.*`).
`session_id` is gone from these params; every desktop caller sends `owner`.
- An account connect runs the same operation lifecycle on a background
thread, under the profile's scope, so the watcher reads the account and
settles the operation. A second connect for an app that is already
connecting returns the open operation and mints nothing.
- `connection.update` carries `owner`. An account operation has no session to
address, so its updates go out on the session-less broadcast path.
* feat(mcp-catalog): eighteen more bundled entries name their hosted connector
A bundled MCP entry and a hosted connector for the same app are one card
on the Connectors page only when the manifest names its hosted twin.
Linear and Notion had the field. These entries get it too: airtable,
asana, attio, calendly, dropbox, figma, railway, supabase, todoist,
betterstack, canva, cloudflare, datadog, intercom, neon, sentry, stripe
and vercel. Atlassian maps to two hosted connectors and Prisma Postgres
is not clearly the same app, so both stay without one.
* refactor(connectors): the account handlers share one gate, one params model and one write table
The six account-level handlers each repeated the availability gate, the
auth catch and the catch-all reply. One decorator now owns that, and each
handler validates its params with its contract model instead of a ladder
of isinstance checks. The five connection RPCs share one guard for the
unexpected-failure reply.
The four write composers for the member rules were the same function
with a different list key and polarity. They are one table now.
The owner union lives in contracts/common.py, so the params side and the
event side stop declaring it twice and the import cycle is gone.
An account operation start carries one event and a flag, so the wait for
the sign-in link blocks instead of polling every 50 ms. run_operation
loses its two account-only parameters; drive_operation is the second
entry point.
Tests: four deleted (they exercised pydantic or the mock), three merged
into tables, two added (a client that still sends the old top-level
session_id is refused; all six account RPCs run off the server loop).
The shared reply helper and the HTTP and managed-client fakes move to
one place each. Comments are one line or gone.
* fix(connectors): a missing tool-list route reads as "unavailable", not "connector gone"
The tool-list read treated every 404 as the portal's "this connector is
not in the catalog" answer. It deleted the cache entry and answered
CONNECTOR_NOT_FOUND, so a page would offer to remove an app that is
connected and works. A portal that does not serve the route yet answers
a bare 404 for every app.
Only the portal's own {"error": "connector_not_found"} means the
connector is gone. Any other 404 is now a tool-list outage: the cached
list is served as stale, or the RPC answers TOOLS_UNAVAILABLE.
* fix(connectors): a connect from the page returns to the app after sign-in
The sign-in link carries a return target only when the session's surface
is the desktop. A chat session binds that surface. An account-owned call
has no chat session, so nothing bound it: the link was minted without a
return target and the browser ended on the portal's done page instead of
coming back to Hermes.
Every account-owned call now runs with the process's own surface bound,
next to its profile scope. The operation thread copies that context, so
the first link and every reissued link carry the return target and the
operation id.
* test(connectors): defer the new connector RPC coverage
The tests for the new account RPCs, the portal client, the tool-list cache
and the rule composer leave this PR and come back in one later change, after
the API is settled. The same was done for #111008.
Kept: the edits that existing tests need because the five connection RPCs
now take `owner` instead of `session_id`, and the rename of the managed
client seam.
Removed: six new test files, their two fakes and the gateway conftest, and
the new cases in test_mcp_catalog.py, test_connectors_gateway_client.py,
gateway-rpc.test.ts and notifications.test.ts. Reverting this commit restores
all of them.
* fix(cli): the connection panel hands the tool thread back at once
The classic CLI's connection callback waited on a queue for the user's first
decision. The operation's watcher starts only after the callback returns, and
the watcher is what polls a hosted account, runs the 300-second deadline and
sees Ctrl+C.
For a hosted connector the panel opens on the sign-in link, where the only
key that filled the queue was Cancel. The account was never polled: the user
signed in, the panel never changed, and Esc reported the app as skipped.
Ctrl+C set the interrupt flag but left the thread parked on the queue, so the
turn never ended.
The callback now opens the panel and returns, as the gateway's callback does
for the desktop and the Ink TUI. The panel's actions already reach the
operation through apply_answer on the UI thread, so the queue is removed. An
install with a form still waits for Connect, because the backend starts no
work for a pending row. Ctrl+C now settles the operation as `interrupt`, and
open rows become `not_connected`.
Checked on the e2e rig with the fake tool gateway: hosted connect completes on
the third status read; Ctrl+C ends the turn and the polling stops; an MCP
install with a plain and a secret field still saves config and both values.
* fix(connectors): "run it again" lives in the library, so the classic CLI can use it
Making a new sign-in link for a failed or expired hosted connector was
implemented only in the JSON-RPC layer (`_reissue`). The classic CLI does not
go through JSON-RPC: its Connect button on a failed row called apply_answer,
which does nothing for a hosted operation because it has no MCP runner. The
panel showed "Waiting…" until the deadline.
`tools.connectors.run.reissue(operation, names)` now holds the checks and the
per-kind action, and returns a refusal reason or None. The gateway maps each
reason to the same JSON-RPC error as before. The CLI calls it for a hosted
row; a refusal is shown on the row. MCP rows keep their path, because Connect
on a failed MCP row re-sends the form values.
Checked on the e2e rig: a scripted failed sign-in, then Connect: a second mint
with `reinitiate: true`, a new link with a new connection id, then connected.
* feat(connectors): the account list and disconnect go through the portal
`connectors.accounts` and `connectors.accounts.remove` called the tool
gateway. They now call the portal's account-management routes
(`GET /api/v1/connectors/accounts`, `DELETE /api/v1/connectors/accounts/{id}`),
which apply the organisation membership checks and write the disconnect audit
row. There is no fallback to the gateway when the portal is unavailable, and a
removal is never retried.
The read of ONE account stays on the gateway (`GET v1/connectors/accounts/{id}`):
the portal has no such route, and the operation watcher polls it once per second.
`ConnectorClient.list_accounts` and `delete_account` are removed. The removed
account's reply model carries `connector`, which both services send.
* fix(connectors): the account RPCs answer what the portal really sends
Checked against the portal source and against the staging and production
services.
- Errors are read from the upstream error code, not the HTTP status. A rule
write answered 409 for a stale revision and for a user with no organisation;
both read as "the policy changed". `org_required` is now `ORG_REQUIRED` and
403 `no_access` is `ORG_ACCESS_DENIED` on every account RPC; only a rejected
sign-in is `NEEDS_NOUS_AUTH`. `connectors.list` and `connectors.connect` with
the account owner map these too.
- `connectors.policy.get` and `connectors.policy.set` carry `effective`: the
portal's own result for this user, with its stamp and without provider or
subject ids. Nothing is recomputed locally.
- A rule write needs the revision the user saw: `expected_revision` is required
and must be a revision string; a bad one is refused before any HTTP call.
- A tool row carries `no_auth`; a list without the upstream flag is an invalid
answer, not `false`.
- `connectors.accounts.remove` returns the app of the removed account. An
invalid id is `INVALID_PARAMS`.
- The tool-list cache is per signed-in member (a hash of the token's `sub`),
so two Nous accounts on one profile do not share entries.
- A malformed slug is a local error, not a 404 from a server nobody called.
Live, staging: no revision and a malformed revision refused locally; a good
revision wrote one disabled Gmail tool and returned it in `effective`; the
same revision again answered `POLICY_CONFLICT`; the list row showed the tool;
the restore brought the member rules back to the start. Live, staging and
production, read-only: all 60 tool lists (5483 tools) parse.
* fix(connectors): the operation RPCs match their contract; a settled card cannot start a new link
Found by two adversarial reviews of the RPC layer and its types.
- `connectors.connect` from a chat session with no open operation is refused
(`UNKNOWN_OPERATION`). It used to call `manage_connections` through the tool
registry with no card: it made a link nobody watched, returned a reply
without the required `settled` field, and named an operation that was never
registered. There is one way into an operation: the agent's call, or the
account owner's `connectors.connect`. "Run it again" inside an open
operation is unchanged.
- `connection.update` for a session is routed by session key AND profile; two
profiles with the same key no longer cross-deliver a sign-in link. The event
payload gets the same redaction as the RPC replies.
- `connection.respond` runs on the long-handler pool: an approval can start MCP
OAuth discovery, which blocked every RPC of the gateway while it ran.
- `connectors.list` rows are a closed snake_case model: `connector`, `enabled`,
`connected`, `connection_status`, `status_reason`, `gateway_disabled_tools`.
The last one is display data: the gateway enforces the rules, the backend
only passes the list on. The phantom `name` and `description` are gone, and
the desktop uses the generated types instead of hand-written copies.
- `tools_listing` (model-only data) no longer rides on `connectors.operation.status`.
- `unavailable` is removed from the target states and settle reasons: nothing
produces it. The contract generator now fails when a contract enum and its
domain enum differ.
- `ConnectorErrorReason` is part of the generated TypeScript and OpenRPC.
- The desktop sends `connection.respond` on the socket that holds the session,
as wake and reissue already did.
- Contract violations are logged every time, at error level.
- An account connect whose prepare step is slow returns the live operation
instead of an error while the operation keeps running.
- The MCP-manifest `connector` field leaves this PR (it moves to a later one
on top of the catalog-reader change). `hermes_cli/mcp_catalog.py` and
`optional-mcps/` are untouched by this PR again.
anti-slop: no net-new findings (15 touched files).
* fix(connectors): the model gets no sign-in link wherever a card exists; side agents cannot connect
The flag that tells the model "a connection card exists" was the session
platform (`== "desktop"`). The Ink TUI and the classic CLI also draw a card,
so there a connector call on an unconnected app handed the model the raw
`connect_url` and told it to pass the link to the user.
- The agent turn now declares how a link can reach the user
(`tools/connectors/turn.py`): CARD when the agent was built with a
connection callback, SIDE for a subagent or a background turn, LINK for a
headless run (`-q`, cron, ACP, api_server, messaging). It is set once per
tool batch in the agent loop and read by the connector dispatch path, which
never sees the agent. The session platform decides return-to-app only.
- CARD: the result carries `connect_card_available` and our hint, never the
link and never the gateway's own hint.
- SIDE: subagents (`delegate_tool`), gateway background turns and the classic
CLI `/bg` are built with `side_agent=True`. They hold no `manage_connections`
tool on any path that derives the tool list, and a connector call on an
unconnected app gets no link, only "report this to the main agent".
- LINK is unchanged.
- The hosted path with no card builds a detached operation, as the MCP path
does, so no `connection.update` is emitted for an operation no client asked
for. Names and docstrings that said "off desktop" now say "no card".
- A settled card is dead on the desktop: `reissueConnectionTarget` and
`respondToConnectionRequest` share one guard and send nothing for a settled
or unknown operation.
- The model-facing settled result no longer carries `connection_id`; the model
repeated it to the user.
Shown on the real clients with a real model (rig, fake tool gateway): Ink TUI
and classic CLI get `connect_card_available` and no link, the model opens the
card, the account connects, the retried call succeeds; `-q` still gets the
link; a subagent and a background turn have no `manage_connections` and get
the no-link hint; on the desktop a card settled with Continue has no enabled
control and sends no RPC.
* feat(tools): every call made through tool_search + tool_call shows a real label on all three clients
A bridged call showed as a generic `tool_call` row in the Ink TUI and as
`⚡ tool_call` in the classic CLI, because the display looked the name up in
the tool registry and bridged names are made at run time. The desktop labelled
only batches that were all hosted connector calls, by parsing names itself.
- `tools/tool_labels.py` is the one place that turns a bridged call into a
label: kind, app, action, emoji and text. Hosted: `connectors__gmail__GMAIL_SEND_EMAIL`
→ "Gmail · send email". MCP: "Linear · list issues". A local deferred tool
keeps its own emoji, verb and primary-argument preview. A batch gets exactly
one label per entry, always; an entry with no name gets a generic label.
- Classic CLI: one row per inner call; the duration on the last row; the
failure text on the row of the call that failed. With friendly labels off
it prints what it printed before.
- Gateway: tool start, progress and complete events and stored transcript rows
carry a typed `labels` field. It does not depend on the classic CLI's
display setting. Clients no longer parse tool names.
- Ink TUI: rows from the labels; the verbose trail keeps Args and Result.
- Desktop: `ConnectorExecution` renders hosted, MCP and mixed turns from the
labels, one row per call. The labels reach the row under a key no tool
argument can use. The connect card it drew under a failed tool result is
gone: after `CONNECTION_REQUIRED` the one way in is the agent's own
`manage_connections` call.
- `tool_search` and `tool_describe` rows read "Searching tools · <query>" and
"Reading tool details · N tools".
Shown on the real desktop (video and screenshots), the Ink TUI and the classic
CLI with the rig: hosted rows, MCP rows, a two-entry batch, a failed entry, a
`CONNECTION_REQUIRED` row with no card under it, labels after a reload, and the
desktop rows with the classic CLI setting off.
* fix(connectors): the model can tell "hosted tools unavailable" from "no such tool"; manage_connections routes MCP names correctly
- A failed hosted search or describe used to return nothing, by design, so the
model saw only local tools and told the user that a connected app was
missing. The local results are unchanged; when the hosted leg failed, the
`tool_search` and `tool_describe` results carry
`connectors: {status: "unavailable", reason: "unreachable" | "sign_in_expired"}`
and one hint line. A rejected token is `sign_in_expired`; an entitlement
refusal or a shut gate adds nothing. `tool_describe` no longer lists those
names under `not_found` next to "search again".
- NS-932. The description now says which side a name belongs to: a bare name
is a hosted connector account; `mcp: true` only when the user asks for an MCP
server, a local server or an install, or when the name exists only in the
catalog; connect and reconnect are hosted verbs, install, enable and
authorize are MCP verbs. It names the three clients that draw a card.
- A misrouted target is refused with the call that works. Only when the
gateway does not know the connector (confirmed on that failure path) and the
name is a catalog entry does the target fail with "X is a local MCP server.
Call manage_connections with action install ...". It is a per-target
outcome: other targets of the same call keep their links and their card. A
vendor failure on a name both sides know stays an ordinary failed row. The
MCP side mirrors it, and never for an entry that is only not installed.
- "Do not re-ask after a skip or a timeout" no longer stops the model when the
USER asks for that app again; the description and the settled-result notes
say so. A builder saw the model refuse a direct user request.
Shown on the Ink TUI and the classic CLI with a real model: a dead gateway and
a 401; "connect fxmail" goes hosted; "install the fx-noauth MCP server" goes
MCP; "connect fx-noauth" reaches the MCP install card in one corrective round
with no hosted mint; a two-target call where one is misrouted still connects
the other with exactly one mint.
* fix(tui): the connection card answers every key, shows what is happening, and is dead once settled
Reproduced on the real Ink TUI with the rig, then fixed:
- The keyboard was dead during the sign-in wait: the card kept a `submitting`
flag that the normal OAuth path never cleared, and Esc went through the same
guard. The in-flight state now belongs to the answered row and clears when
that row moves, when any later frame of the operation arrives, or after
five seconds. Esc skips the row in every phase; Ctrl+C interrupts the turn
(the input handler had no branch for this overlay); Shift+arrows scroll the
transcript and the card ignores them; arrow keys no longer move the text
cursor and the field focus at once.
- The card was lost at turn idle: the overlay flag was cleared while the
operation stayed in the store, and a resume dropped the pending card. The
flag survives idle, a resume shows the pending card again, a session switch
clears it.
- States with no branch: `not_connected` and a row with no link fell into the
credential form; `expired` vanished with no note. The title and the row text
now name the action (connect, reconnect, install, enable, authorize); a
failed or expired row with no fields offers Try again / Skip; a failed row
WITH fields reopens the form over the typed draft, with the failure above it.
- A settled card is dead: at settle the overlay closes and one transcript line
per app states the outcome. A settled or dismissed operation id is
remembered, so no replay or resume can reopen its card. Esc in the last
"Finishing…" moment hides the card and still writes the outcome lines.
- A failed `connection.respond` and a browser that did not open are shown on
the card in one sentence.
Also: `tui_gateway/connector_payload.py` redacted the BOOLEAN `secret` flag of
a credential field to the string "[REDACTED]". On the desktop every credential
field therefore rendered as a password and lost its prefilled default. A
boolean is no longer redacted.
* chore(connectors): remove the comments and docstrings this branch added
Deletions only. Kept: tool directives (`# noqa`, `// eslint-disable`, ...),
`// SAFETY:` lines, and the docstrings of the contract models under
`tui_gateway/contracts/`, which become the descriptions in the generated
OpenRPC and TypeScript.
Checked that no code changed: every Python file has the same AST as before
once docstrings and `pass` are ignored (62 files), and every TypeScript file
prints the same with comments stripped by the TypeScript printer (32 files).
The generated contract files are unchanged.
* fix(connectors): a card restored after a reload answers again; every account RPC names auth and org failures
Found by the end-to-end runs on the pushed head.
- Desktop: after a window reload, Continue on the restored card sent nothing.
The answer looked up the backend that holds the session with the runtime
session id, the lookup wants the stored id, and a failed lookup returned
silently. When the lookup gives no owner the answer now goes out on the
window's active socket, which is what main does.
- `connectors.policy.get` answered `POLICY_UNAVAILABLE` for a rejected sign-in,
a refused scope, a non-member and a missing organisation alike: the handler
runs with the gateway's globals and did not import the reason enum, so its
own error mapping raised. `connectors.accounts.remove` caught auth failures
in its generic branch. `org_required` was mapped on `policy.set` only. All
six account RPCs now answer `NEEDS_NOUS_AUTH`, `FORBIDDEN_SCOPE`,
`ORG_ACCESS_DENIED` and `ORG_REQUIRED` for those four upstream answers.
765 lines
31 KiB
Python
765 lines
31 KiB
Python
"""Behavior tests for the connector leg of the tool_search bridge.
|
|
|
|
DI-callable idiom (test_managed_tool_gateway.py precedent): remote legs are
|
|
injected as plain callables; no module mocks, no network. Local-only behavior
|
|
is pinned byte-identical when the remote leg fails (D32).
|
|
"""
|
|
|
|
import json
|
|
import logging
|
|
|
|
import pytest
|
|
|
|
from agent.tool_dispatch_helpers import _peel_bridge_call
|
|
from tools.connectors.gateway.bridge import ConnectorLeg, connector_describe
|
|
from tools.connectors.gateway.errors import GatewayAuthError
|
|
from tools.tool_search import (
|
|
CONNECTOR_BATCH_SENTINEL,
|
|
ToolSearchConfig,
|
|
assemble_tool_defs,
|
|
dispatch_tool_describe,
|
|
dispatch_tool_search,
|
|
resolve_underlying_call,
|
|
)
|
|
from tools.tool_search_validation import normalize_tool_call_entries
|
|
|
|
|
|
def _tool_search_description(tool_defs):
|
|
# session_search is in the default defer set, so the bridge activates in
|
|
# both arms for the same reason: a deferrable local tool exists.
|
|
defs = tool_defs + [{"type": "function", "function": {
|
|
"name": "session_search", "description": "Search past sessions", "parameters": {}}}]
|
|
assembled = assemble_tool_defs(
|
|
defs, context_length=200_000, config=ToolSearchConfig.from_raw({"enabled": "on"}))
|
|
assert assembled.activated
|
|
return next(td["function"]["description"] for td in assembled.tool_defs
|
|
if td["function"]["name"] == "tool_search")
|
|
|
|
|
|
def test_tool_search_names_manage_connections_only_when_the_session_has_it():
|
|
"""The model learns that connectors__ names belong to accounts managed by
|
|
manage_connections from the tool_search description, but only when that tool is in the
|
|
session. Signed out (or connectors off) the tool is absent and the description must not
|
|
name a tool the model cannot call."""
|
|
with_connections = _tool_search_description(_local_defs())
|
|
assert "manage_connections" in with_connections
|
|
assert "connectors__" in with_connections
|
|
|
|
without = _tool_search_description(
|
|
[td for td in _local_defs() if td["function"]["name"] != "manage_connections"])
|
|
assert "manage_connections" not in without
|
|
|
|
|
|
def _local_defs():
|
|
"""One deferrable (mcp-toolset) tool, one core-shaped tool."""
|
|
return [
|
|
{"type": "function", "function": {"name": "manage_connections", "parameters": {}}},
|
|
{
|
|
"type": "function",
|
|
"function": {
|
|
"name": "mcp__github__create_issue",
|
|
"description": "Create a GitHub issue",
|
|
"parameters": {"type": "object", "properties": {}, "required": ["title"]},
|
|
},
|
|
},
|
|
]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# resolve_underlying_call: batch shapes
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_resolve_single_connector_entry_returns_sentinel():
|
|
name, args, err = resolve_underlying_call(
|
|
{"calls": [{"name": "connectors__gmail__SEND_EMAIL", "arguments": {"to": "x"}}]}
|
|
)
|
|
assert err is None
|
|
assert name == CONNECTOR_BATCH_SENTINEL
|
|
assert args["calls"][0]["name"] == "connectors__gmail__SEND_EMAIL"
|
|
assert args["calls"][0]["arguments"] == {"to": "x"}
|
|
|
|
|
|
def test_resolve_multi_local_batch_echoes_first_entry_as_the_retry_shape():
|
|
# The correction restates the valid single-entry shape with the caller's OWN first
|
|
# entry (a 9B model re-sent the identical two-entry array when told only the rule).
|
|
first = {"name": "some_local_tool", "arguments": {"query": "alpha", "limit": 20}}
|
|
name, args, err = resolve_underlying_call({"calls": [first, {"name": "another_local", "arguments": {}}]})
|
|
assert name is None
|
|
assert "you sent 2" in err
|
|
retry = err.split("Retry with only: ", 1)[1].split(" then issue", 1)[0]
|
|
assert json.loads(retry) == {"calls": [first]}
|
|
|
|
|
|
def test_resolve_unknown_name_points_at_tool_search_not_direct_call():
|
|
# An unregistered name (typically a deferred MCP tool cited by its bare suffix) must
|
|
# NOT be told "call it directly" — that is the opposite of the required correction.
|
|
from tools.registry import registry
|
|
|
|
name, args, err = resolve_underlying_call({"name": "not_a_real_tool", "arguments": {}})
|
|
assert name is None
|
|
assert "not a known tool name" in err and "call it directly" not in err.lower()
|
|
registry.register(name="mcp__mempalace__mempalace_search", toolset="mcp-mempalace",
|
|
handler=lambda a, **kw: "{}",
|
|
schema={"name": "mcp__mempalace__mempalace_search", "description": "x",
|
|
"parameters": {"type": "object", "properties": {}}})
|
|
_, _, err = resolve_underlying_call({"name": "mempalace_search", "arguments": {}})
|
|
registry.deregister("mcp__mempalace__mempalace_search")
|
|
assert "Did you mean 'mcp__mempalace__mempalace_search'?" in err
|
|
_, _, err = resolve_underlying_call({"name": "read_file", "arguments": {}})
|
|
assert "directly-listed tool" in err and "not a known tool" not in err
|
|
|
|
|
|
def test_resolve_legacy_connector_single_shape_routes_to_sentinel():
|
|
name, args, err = resolve_underlying_call(
|
|
{"name": "connectors__gmail__CREATE_EMAIL_DRAFT", "arguments": {}}
|
|
)
|
|
assert err is None
|
|
assert name == CONNECTOR_BATCH_SENTINEL
|
|
assert len(args["calls"]) == 1
|
|
|
|
|
|
def test_normalize_parses_string_envelope_batch():
|
|
"""#114484: a model-emitted JSON-string batch envelope parses like the array form."""
|
|
calls = [{"name": "session_search", "arguments": {"query": "x"}}]
|
|
entries, err = normalize_tool_call_entries({"calls": json.dumps(calls)})
|
|
assert err is None
|
|
assert entries == calls
|
|
|
|
|
|
def test_normalize_parses_string_envelope_single_dict():
|
|
"""#114484: a stringified single dict normalizes to a batch of one."""
|
|
entries, err = normalize_tool_call_entries(
|
|
{"calls": json.dumps({"name": "session_search", "arguments": {"query": "x"}})}
|
|
)
|
|
assert err is None
|
|
assert entries == [{"name": "session_search", "arguments": {"query": "x"}}]
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"bad,expected_fragment",
|
|
[
|
|
({}, "requires 'calls'"),
|
|
({"calls": []}, "non-empty array"),
|
|
({"calls": [{"arguments": {}}]}, "requires a 'name'"),
|
|
({"calls": [{"name": "tool_search"}]}, "itself a bridge tool"),
|
|
({"calls": [{"name": "x", "arguments": "not json {"}]}, "not valid JSON"),
|
|
({"calls": [{"name": "x", "arguments": 42}]}, "must be an object"),
|
|
({"calls": "nope"}, "not valid JSON"),
|
|
({"calls": json.dumps({"query": "x"})}, "requires a 'name'"),
|
|
],
|
|
)
|
|
def test_normalize_rejects_malformed_batches(bad, expected_fragment):
|
|
entries, err = normalize_tool_call_entries(bad)
|
|
assert entries == []
|
|
assert expected_fragment in (err or "")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# dispatch_tool_search: remote merge
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _fake_connector_search(queries):
|
|
assert queries == [{"use_case": "send an email"}]
|
|
return ConnectorLeg(payload={
|
|
"results": [
|
|
{"index": 1, "use_case": "send an email", "tools": ["GMAIL_SEND_EMAIL", "ORPHAN_TOOL"]},
|
|
],
|
|
"schemas": {
|
|
"GMAIL_SEND_EMAIL": {
|
|
"connector": "gmail",
|
|
"tool": "GMAIL_SEND_EMAIL",
|
|
"description": "Send an email via gmail",
|
|
"input_schema": {"type": "object", "required": ["to", "subject"]},
|
|
},
|
|
# ORPHAN_TOOL deliberately has no schema entry: without a
|
|
# connector it cannot compose a callable name and must be dropped.
|
|
},
|
|
"connections": [{"connector": "gmail", "connected": False, "description": ""}],
|
|
})
|
|
|
|
|
|
def _registered_local_defs():
|
|
"""Deferrable local tools the registry knows, so they enter the BM25 catalog: an issue
|
|
tracker whose descriptions mention email notifications, and an unrelated tool."""
|
|
from tools.registry import registry
|
|
|
|
specs = [
|
|
("mcp__tracker__create_issue", "Create an issue. Sends an email notification to the team."),
|
|
("mcp__tracker__list_issues", "List issues in a project. Email digests are optional."),
|
|
("mcp__tracker__archive_project", "Archive a project and its issues."),
|
|
]
|
|
defs = []
|
|
for name, desc in specs:
|
|
schema = {"name": name, "description": desc,
|
|
"parameters": {"type": "object", "properties": {"id": {"type": "string"}}}}
|
|
registry.register(name=name, handler=lambda a, **k: "{}", schema=schema, toolset="mcp-tracker")
|
|
defs.append({"type": "function", "function": schema})
|
|
return [{"type": "function", "function": {"name": "manage_connections", "parameters": {}}}] + defs, [n for n, _ in specs]
|
|
|
|
|
|
def test_connector_intent_is_not_starved_by_local_tools_sharing_one_word():
|
|
"""The reported bug: with a large local catalog, tools that merely shared 'email' filled
|
|
every slot and the gmail connector tool never appeared. Ranked as one corpus with the
|
|
rarest-token gate ('gmail' is in one document), the connector tool is the only result."""
|
|
from tools.registry import registry
|
|
|
|
defs, names = _registered_local_defs()
|
|
try:
|
|
out = json.loads(dispatch_tool_search(
|
|
{"queries": ["send gmail email"], "limit": 5},
|
|
current_tool_defs=defs,
|
|
connector_search=lambda q: ConnectorLeg(payload={
|
|
"results": [{"use_case": "send gmail email", "tools": ["GMAIL_SEND_EMAIL"]}],
|
|
"schemas": {"GMAIL_SEND_EMAIL": {
|
|
"connector": "gmail", "tool": "GMAIL_SEND_EMAIL",
|
|
"description": "Send an email via gmail", "input_schema": {}}},
|
|
})))
|
|
assert out["results"][0]["matches"] == ["connectors__gmail__SEND_EMAIL"]
|
|
finally:
|
|
for n in names:
|
|
registry.deregister(n)
|
|
|
|
|
|
def test_both_sources_answer_within_one_limit():
|
|
"""When a local MCP server and a connector both serve the same service, both surface,
|
|
ranked by the same BM25 pass, and `limit` caps the group as a whole."""
|
|
from tools.registry import registry
|
|
|
|
defs, names = _registered_local_defs()
|
|
try:
|
|
out = json.loads(dispatch_tool_search(
|
|
{"queries": ["tracker create issue"], "limit": 2},
|
|
current_tool_defs=defs,
|
|
connector_search=lambda q: ConnectorLeg(payload={
|
|
"results": [{"use_case": "tracker create issue", "tools": ["TRACKER_CREATE_ISSUE"]}],
|
|
"schemas": {"TRACKER_CREATE_ISSUE": {
|
|
"connector": "tracker", "tool": "TRACKER_CREATE_ISSUE",
|
|
"description": "Create a tracker issue", "input_schema": {}}},
|
|
})))
|
|
matches = out["results"][0]["matches"]
|
|
assert len(matches) == 2
|
|
assert set(matches) == {"mcp__tracker__create_issue", "connectors__tracker__CREATE_ISSUE"}
|
|
finally:
|
|
for n in names:
|
|
registry.deregister(n)
|
|
|
|
|
|
def test_search_composes_lowercase_connector_from_vendor_cased_schema():
|
|
# The gateway search surface leaks vendor-cased connector slugs for
|
|
# custom toolkits; the composed name must carry the lowercase catalog
|
|
# form or the gateway's own policy gates refuse the call.
|
|
def cased_search(queries):
|
|
return ConnectorLeg(payload={
|
|
"results": [{"index": 1, "tools": ["CUSTOM_X_READ"]}],
|
|
"schemas": {
|
|
"CUSTOM_X_READ": {
|
|
"connector": "CUSTOM_X",
|
|
"tool": "CUSTOM_X_READ",
|
|
"description": "d",
|
|
"input_schema": {},
|
|
}
|
|
},
|
|
})
|
|
|
|
out = json.loads(
|
|
dispatch_tool_search(
|
|
{"queries": ["custom_x read"]},
|
|
current_tool_defs=_local_defs(),
|
|
connector_search=cased_search,
|
|
)
|
|
)
|
|
assert "connectors__custom_x__READ" in out["results"][0]["matches"]
|
|
|
|
|
|
def test_search_merges_remote_hits_tagged_as_connectors():
|
|
out = json.loads(
|
|
dispatch_tool_search(
|
|
{"queries": ["send an email"]},
|
|
current_tool_defs=_local_defs(),
|
|
connector_search=_fake_connector_search,
|
|
)
|
|
)
|
|
matches = out["results"][0]["matches"]
|
|
composed = "connectors__gmail__SEND_EMAIL"
|
|
assert composed in matches
|
|
assert all("ORPHAN_TOOL" not in m for m in matches)
|
|
record = out["tools"][composed]
|
|
assert record["source"] == "connectors"
|
|
assert record["source_name"] == "gmail"
|
|
assert record["required"] == ["to", "subject"]
|
|
|
|
|
|
@pytest.mark.parametrize("order", [("GMAIL_FETCH_PROFILE", "FETCH_PROFILE"), ("FETCH_PROFILE", "GMAIL_FETCH_PROFILE")])
|
|
def test_search_keeps_only_the_twin_a_colliding_name_reaches(order, caplog):
|
|
"""Composition is not injective: GMAIL_FETCH_PROFILE and a literal FETCH_PROFILE on
|
|
gmail both compose to connectors__gmail__FETCH_PROFILE, and describe/execute decode
|
|
that name to GMAIL_FETCH_PROFILE. If a vendor ever ships both, search must not
|
|
describe the literal under a name that runs the prefixed tool, whichever the
|
|
gateway listed first, and must say so in the log rather than alias silently."""
|
|
def twins(queries):
|
|
return ConnectorLeg(payload={
|
|
"results": [{"index": 1, "tools": list(order)}],
|
|
"schemas": {
|
|
"GMAIL_FETCH_PROFILE": {"connector": "gmail", "tool": "GMAIL_FETCH_PROFILE",
|
|
"description": "prefixed twin", "input_schema": {}},
|
|
"FETCH_PROFILE": {"connector": "gmail", "tool": "FETCH_PROFILE",
|
|
"description": "literal twin", "input_schema": {}},
|
|
},
|
|
})
|
|
|
|
with caplog.at_level(logging.WARNING, logger="tools.connectors.search"):
|
|
out = json.loads(dispatch_tool_search(
|
|
{"queries": ["gmail fetch profile"]},
|
|
current_tool_defs=_local_defs(),
|
|
connector_search=twins,
|
|
))
|
|
assert out["results"][0]["matches"] == ["connectors__gmail__FETCH_PROFILE"]
|
|
assert out["tools"]["connectors__gmail__FETCH_PROFILE"]["description"] == "prefixed twin"
|
|
warnings = [r.getMessage() for r in caplog.records if r.levelno == logging.WARNING]
|
|
assert len(warnings) == 1
|
|
assert "GMAIL_FETCH_PROFILE" in warnings[0] and "FETCH_PROFILE" in warnings[0]
|
|
|
|
|
|
def test_search_limit_caps_the_group_across_both_legs_and_counts_total():
|
|
def many_hits(queries):
|
|
slugs = [f"CUSTOM_X_TOOL_{i}" for i in range(9)]
|
|
return ConnectorLeg(payload={
|
|
"results": [{"index": 1, "tools": slugs}],
|
|
"schemas": {
|
|
s: {"connector": "custom_x", "tool": s, "description": "widget", "input_schema": {}}
|
|
for s in slugs
|
|
},
|
|
})
|
|
|
|
out = json.loads(
|
|
dispatch_tool_search(
|
|
{"queries": ["custom_x widget"], "limit": 3},
|
|
current_tool_defs=_local_defs(),
|
|
connector_search=many_hits,
|
|
)
|
|
)
|
|
matches = out["results"][0]["matches"]
|
|
assert len(matches) == 3 # limit is the per-query cap across BOTH legs
|
|
assert all(m.startswith("connectors__") for m in matches)
|
|
# total_available counts returned remote tools on top of the local catalog
|
|
# (empty here: the fake def is not registry-backed in this test env).
|
|
assert out["total_available"] == 3
|
|
|
|
|
|
def test_search_drops_remote_group_with_mismatched_use_case_echo():
|
|
def misaligned(queries):
|
|
return ConnectorLeg(payload={
|
|
"results": [{"index": 1, "use_case": "SOMETHING ELSE", "tools": ["CUSTOM_X_READ"]}],
|
|
"schemas": {
|
|
"CUSTOM_X_READ": {"connector": "custom_x", "tool": "CUSTOM_X_READ", "description": "d", "input_schema": {}}
|
|
},
|
|
})
|
|
|
|
out = json.loads(
|
|
dispatch_tool_search(
|
|
{"queries": ["send an email"]},
|
|
current_tool_defs=_local_defs(),
|
|
connector_search=misaligned,
|
|
)
|
|
)
|
|
assert not any(m.startswith("connectors__") for m in out["results"][0]["matches"])
|
|
|
|
|
|
def test_search_keeps_local_results_and_names_the_hosted_failure():
|
|
def exploding_search(queries):
|
|
raise RuntimeError("gateway exploded")
|
|
|
|
local_only = json.loads(dispatch_tool_search(
|
|
{"queries": ["send an email"]},
|
|
current_tool_defs=_local_defs(),
|
|
connector_search=lambda queries: ConnectorLeg(),
|
|
))
|
|
with_failure = json.loads(dispatch_tool_search(
|
|
{"queries": ["send an email"]},
|
|
current_tool_defs=_local_defs(),
|
|
connector_search=exploding_search,
|
|
))
|
|
assert "connectors" not in local_only
|
|
connectors = with_failure.pop("connectors")
|
|
assert local_only == with_failure
|
|
assert connectors["status"] == "unavailable" and connectors["reason"] == "unreachable"
|
|
|
|
|
|
def test_search_never_sends_the_gateway_more_use_cases_than_it_accepts():
|
|
"""The gateway's search route returns HTTP 502 above 7 use_cases per request, and one
|
|
tool_search call maps to one gateway request. Seven queries reach it in one request;
|
|
eight are refused before any request is made, so the model gets a retry hint and the
|
|
gateway never sees a request it cannot answer."""
|
|
sent = []
|
|
|
|
def recording_search(use_cases):
|
|
sent.append(use_cases)
|
|
return ConnectorLeg()
|
|
|
|
seven = [f"query {i}" for i in range(7)]
|
|
parsed = json.loads(dispatch_tool_search(
|
|
{"queries": seven}, current_tool_defs=_local_defs(), connector_search=recording_search))
|
|
assert "error" not in parsed
|
|
assert sent == [[{"use_case": q} for q in seven]]
|
|
|
|
sent.clear()
|
|
parsed = json.loads(dispatch_tool_search(
|
|
{"queries": seven + ["query 7"]}, current_tool_defs=_local_defs(),
|
|
connector_search=recording_search))
|
|
assert "too many queries" in parsed["error"]
|
|
assert sent == []
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# dispatch_tool_describe: remote merge
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_describe_merges_remote_schema_and_leaves_misses_in_not_found():
|
|
composed = "connectors__gmail__SEND_EMAIL"
|
|
stale = "connectors__gmail__GONE_TOOL"
|
|
|
|
def fake_describe(names):
|
|
assert set(names) == {composed, stale}
|
|
return ConnectorLeg(payload={
|
|
"tools": {composed: {"description": "Send an email", "parameters": {"type": "object"}}}})
|
|
|
|
out = json.loads(
|
|
dispatch_tool_describe(
|
|
{"names": [composed, stale]},
|
|
current_tool_defs=_local_defs(),
|
|
connector_describe=fake_describe,
|
|
)
|
|
)
|
|
assert out["tools"][composed]["parameters"] == {"type": "object"}
|
|
assert stale in out["not_found"]
|
|
assert "errors" not in out # a connector miss is stale/unknown, not an error
|
|
|
|
|
|
def test_describe_connector_names_fall_to_not_found_when_dark_and_to_connectors_when_the_leg_fails():
|
|
composed = "connectors__gmail__SEND_EMAIL"
|
|
out = json.loads(
|
|
dispatch_tool_describe(
|
|
{"names": [composed]},
|
|
current_tool_defs=_local_defs(),
|
|
connector_describe=lambda names: ConnectorLeg(),
|
|
)
|
|
)
|
|
assert out["not_found"] == [composed]
|
|
|
|
def exploding_describe(names):
|
|
raise RuntimeError("gateway exploded")
|
|
|
|
failed = json.loads(
|
|
dispatch_tool_describe(
|
|
{"names": [composed]},
|
|
current_tool_defs=_local_defs(),
|
|
connector_describe=exploding_describe,
|
|
)
|
|
)
|
|
assert "not_found" not in failed and "hint" not in failed
|
|
assert failed["connectors"]["status"] == "unavailable"
|
|
assert failed["connectors"]["reason"] == "unreachable"
|
|
assert failed["connectors"]["names"] == [composed]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# planner admission: only PURE connector batches are parallel-safe
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_peel_admits_pure_connector_batch_as_sentinel():
|
|
name, args = _peel_bridge_call(
|
|
"tool_call",
|
|
{"calls": [
|
|
{"name": "connectors__gmail__SEND_EMAIL", "arguments": {}},
|
|
{"name": "connectors__slack__POST_MESSAGE", "arguments": {}},
|
|
]},
|
|
)
|
|
assert name == CONNECTOR_BATCH_SENTINEL
|
|
|
|
|
|
def test_peel_keeps_mixed_and_local_batches_as_sequential_barrier():
|
|
mixed = {"calls": [
|
|
{"name": "connectors__gmail__SEND_EMAIL", "arguments": {}},
|
|
{"name": "write_file", "arguments": {"path": "x"}},
|
|
]}
|
|
name, args = _peel_bridge_call("tool_call", mixed)
|
|
assert name == "tool_call" # barrier: local entries never got admission
|
|
|
|
all_local = {"calls": [
|
|
{"name": "write_file", "arguments": {"path": "x"}},
|
|
{"name": "read_file", "arguments": {"path": "x"}},
|
|
]}
|
|
name, _ = _peel_bridge_call("tool_call", all_local)
|
|
assert name == "tool_call"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# run_remote through production dispatch: vendor-slug restoration, the
|
|
# one-pass literal fallback, and the gateway request body
|
|
#
|
|
# tool_call batches re-enter core dispatch once per connector entry, so each
|
|
# entry reaches run_remote alone. The gateway is swapped at the bridge's
|
|
# client factory, the same seam the real client is created through.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _connectors_on(monkeypatch, client_factory):
|
|
from tools.registry import invalidate_check_fn_cache
|
|
from tools.connectors.gateway import bridge, config
|
|
|
|
monkeypatch.setattr(config, "connectors_available", lambda: True)
|
|
monkeypatch.setattr(bridge, "connectors_available", lambda: True)
|
|
monkeypatch.setattr(bridge, "_default_client_factory", client_factory)
|
|
invalidate_check_fn_cache()
|
|
|
|
|
|
def _tool_call(calls):
|
|
import model_tools
|
|
|
|
return json.loads(model_tools.handle_function_call(
|
|
"tool_call", {"calls": calls}, enabled_toolsets=["connections"], session_id="bridge-session",
|
|
skip_pre_tool_call_hook=True, skip_tool_request_middleware=True,
|
|
skip_tool_execution_middleware=True))
|
|
|
|
|
|
def test_execute_falls_back_once_for_literal_slug_without_touching_siblings(monkeypatch):
|
|
class FakeClient:
|
|
def __init__(self):
|
|
self.calls = []
|
|
|
|
def execute(self, planned):
|
|
self.calls.append([plan.tool for plan in planned])
|
|
(plan,) = planned
|
|
if plan.tool == "GRANOLA_FETCH_NOTES":
|
|
return [{"data": None, "error": {"code": "TOOL_NOT_FOUND", "message": "missing"}}]
|
|
if plan.tool == "SLACK_POST_MESSAGE":
|
|
return [{"data": None, "error": {"code": "TOOL_NOT_ALLOWED", "message": "blocked"}}]
|
|
return [{"data": f"ran {plan.tool}", "error": None}]
|
|
|
|
client = FakeClient()
|
|
_connectors_on(monkeypatch, lambda: client)
|
|
out = _tool_call([
|
|
{"name": "connectors__gmail__SEND_EMAIL", "arguments": {}},
|
|
{"name": "connectors__granola__FETCH_NOTES", "arguments": {}},
|
|
{"name": "connectors__slack__POST_MESSAGE", "arguments": {}},
|
|
])
|
|
|
|
# Every entry crosses the wire under its restored vendor slug. Only the
|
|
# confirmed TOOL_NOT_FOUND miss is retried, once, under the literal slug;
|
|
# the success and the TOOL_NOT_ALLOWED sibling are never re-sent.
|
|
assert client.calls == [
|
|
["GMAIL_SEND_EMAIL"], ["GRANOLA_FETCH_NOTES"], ["FETCH_NOTES"], ["SLACK_POST_MESSAGE"]]
|
|
assert out["results"][0]["response"] == "ran GMAIL_SEND_EMAIL"
|
|
assert out["results"][1] == {
|
|
"index": 1, "name": "connectors__granola__FETCH_NOTES", "response": "ran FETCH_NOTES"}
|
|
assert out["results"][2]["error"]["code"] == "TOOL_NOT_ALLOWED"
|
|
assert out["success_count"] == 2 and out["error_count"] == 1
|
|
|
|
|
|
@pytest.mark.parametrize("fail_at", ["GRANOLA_FETCH_NOTES", "FETCH_NOTES"])
|
|
def test_execute_transport_failure_degrades_only_the_failing_entry(monkeypatch, fail_at):
|
|
class FakeClient:
|
|
def execute(self, planned):
|
|
(plan,) = planned
|
|
if plan.tool == fail_at:
|
|
raise RuntimeError("transport failed")
|
|
if plan.tool == "GRANOLA_FETCH_NOTES":
|
|
return [{"data": None, "error": {"code": "TOOL_NOT_FOUND", "message": "missing"}}]
|
|
return [{"data": "sibling", "error": None}]
|
|
|
|
_connectors_on(monkeypatch, FakeClient)
|
|
out = _tool_call([
|
|
{"name": "connectors__gmail__SEND_EMAIL", "arguments": {}},
|
|
{"name": "connectors__granola__FETCH_NOTES", "arguments": {}},
|
|
])
|
|
|
|
# Whether the primary send or the literal retry blows up, only that entry
|
|
# degrades to PROVIDER_ERROR; the sibling keeps its result.
|
|
assert out["results"][0]["response"] == "sibling"
|
|
assert out["results"][1]["error"]["code"] == "PROVIDER_ERROR"
|
|
assert out["success_count"] == 1 and out["error_count"] == 1
|
|
|
|
|
|
class _FakeResponse:
|
|
def __init__(self, body):
|
|
self.status_code = 200
|
|
self._body = body
|
|
self.text = json.dumps(body)
|
|
|
|
def json(self):
|
|
return self._body
|
|
|
|
|
|
class _RecordingTransport:
|
|
"""Records every outgoing request; answers each with `data` echoes."""
|
|
|
|
def __init__(self):
|
|
self.requests = []
|
|
|
|
def request(self, method, url, *, headers=None, json=None, timeout=None):
|
|
self.requests.append({"method": method, "url": url, "json": json})
|
|
tools = (json or {}).get("tools") or []
|
|
results = [
|
|
{"index": i, "connector": t.get("connector"), "tool": t.get("tool"), "data": "ok"}
|
|
for i, t in enumerate(tools)
|
|
]
|
|
return _FakeResponse(
|
|
{
|
|
"results": results,
|
|
"successCount": len(results),
|
|
"errorCount": 0,
|
|
"totalCount": len(results),
|
|
}
|
|
)
|
|
|
|
|
|
def _recording_client_factory(transport):
|
|
from tools.connectors.gateway.client import ConnectorClient
|
|
|
|
return lambda: ConnectorClient(
|
|
transport=transport,
|
|
endpoint_resolver=lambda: "https://tool-gateway.test",
|
|
header_provider=lambda url: {"Authorization": "Bearer nous-token"},
|
|
)
|
|
|
|
|
|
def _sent_tools(transport):
|
|
assert len(transport.requests) == 1
|
|
return transport.requests[0]["json"]["tools"]
|
|
|
|
|
|
def test_hook_rewrite_and_restored_vendor_slug_reach_the_gateway_request_body(monkeypatch):
|
|
import hermes_cli.plugins as plugins
|
|
|
|
transport = _RecordingTransport()
|
|
_connectors_on(monkeypatch, _recording_client_factory(transport))
|
|
# A pre_tool_call redaction pass: the secret must never leave the process.
|
|
monkeypatch.setattr(plugins, "_dispatch_pre_tool_call_hooks",
|
|
lambda name, args, **kw: (None, {**args, "body": "[REDACTED]"}))
|
|
|
|
out = _tool_call([{"name": "connectors__gmail__SEND_EMAIL",
|
|
"arguments": {"to": "[email protected]", "body": "sk-secret"}}])
|
|
|
|
assert _sent_tools(transport) == [
|
|
{"connector": "gmail", "tool": "GMAIL_SEND_EMAIL",
|
|
"arguments": {"to": "[email protected]", "body": "[REDACTED]"}},
|
|
]
|
|
assert "sk-secret" not in json.dumps(transport.requests[0]["json"])
|
|
assert out["results"][0]["response"] == "ok" # correlation survives the rewrite
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# bridge.connector_describe: composed-name round trip
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_connector_describe_maps_slugs_back_to_composed_names():
|
|
class FakeClient:
|
|
def schemas(self, slugs):
|
|
assert slugs == ["GMAIL_SEND_EMAIL", "SEND_EMAIL"]
|
|
return {
|
|
"schemas": {
|
|
"GMAIL_SEND_EMAIL": {
|
|
"connector": "gmail",
|
|
"tool": "GMAIL_SEND_EMAIL",
|
|
"description": "Send an email",
|
|
"input_schema": {"type": "object"},
|
|
}
|
|
},
|
|
"not_found": [],
|
|
}
|
|
|
|
out = connector_describe(
|
|
["connectors__gmail__SEND_EMAIL", "connectors__broken"],
|
|
availability=lambda: True,
|
|
client_factory=lambda: FakeClient(),
|
|
)
|
|
assert out.payload["tools"]["connectors__gmail__SEND_EMAIL"]["parameters"] == {"type": "object"}
|
|
|
|
|
|
def test_connector_describe_colliding_candidate_slugs_resolve_per_name():
|
|
# connectors__first__SECOND_X nominates (FIRST_SECOND_X, SECOND_X) and
|
|
# connectors__second__X nominates (SECOND_X, X): the shared SECOND_X must
|
|
# not be claimed globally by whichever name came first. Each name takes
|
|
# its own best-ranked resolved candidate — here the first name's prefixed
|
|
# primary is unknown to the gateway, so BOTH names land on SECOND_X.
|
|
class FakeClient:
|
|
def schemas(self, slugs):
|
|
assert slugs == ["FIRST_SECOND_X", "SECOND_X", "X"]
|
|
return {
|
|
"schemas": {
|
|
"SECOND_X": {
|
|
"connector": "second",
|
|
"tool": "SECOND_X",
|
|
"description": "Shared slug",
|
|
"input_schema": {"type": "object"},
|
|
}
|
|
},
|
|
"not_found": ["FIRST_SECOND_X", "X"],
|
|
}
|
|
|
|
out = connector_describe(
|
|
["connectors__first__SECOND_X", "connectors__second__X"],
|
|
availability=lambda: True,
|
|
client_factory=lambda: FakeClient(),
|
|
)
|
|
assert set(out.payload["tools"]) == {
|
|
"connectors__first__SECOND_X",
|
|
"connectors__second__X",
|
|
}
|
|
|
|
|
|
def test_connector_describe_prefers_each_names_prefixed_candidate():
|
|
# When BOTH of a name's candidates resolve, the prefixed primary wins —
|
|
# the literal is only the recovery lane for slugs the encoder never
|
|
# stripped.
|
|
class FakeClient:
|
|
def schemas(self, slugs):
|
|
assert slugs == ["GMAIL_X", "X"]
|
|
return {
|
|
"schemas": {
|
|
"GMAIL_X": {
|
|
"connector": "gmail",
|
|
"tool": "GMAIL_X",
|
|
"description": "prefixed",
|
|
"input_schema": {"type": "object", "title": "prefixed"},
|
|
},
|
|
"X": {
|
|
"connector": "gmail",
|
|
"tool": "X",
|
|
"description": "literal",
|
|
"input_schema": {"type": "object", "title": "literal"},
|
|
},
|
|
},
|
|
"not_found": [],
|
|
}
|
|
|
|
out = connector_describe(
|
|
["connectors__gmail__X"],
|
|
availability=lambda: True,
|
|
client_factory=lambda: FakeClient(),
|
|
)
|
|
assert out.payload["tools"]["connectors__gmail__X"]["description"] == "prefixed"
|
|
|
|
|
|
def test_connector_describe_is_empty_on_unavailable_and_names_the_failure_reason():
|
|
off = connector_describe(["connectors__g__T"], availability=lambda: False)
|
|
assert off == ConnectorLeg()
|
|
|
|
def boom():
|
|
raise RuntimeError("boom")
|
|
|
|
assert connector_describe(
|
|
["connectors__g__T"], availability=lambda: True, client_factory=boom
|
|
) == ConnectorLeg(failure="unreachable")
|
|
|
|
def rejected():
|
|
raise GatewayAuthError("token rejected", code="UNAUTHORIZED", status=401)
|
|
|
|
assert connector_describe(
|
|
["connectors__g__T"], availability=lambda: True, client_factory=rejected
|
|
) == ConnectorLeg(failure="sign_in_expired")
|