@2kw/ai-mcp-server 6.3.0-dev.117 → 6.3.0-dev.118

package/dist/lib/agent-decide.js

@@ -144,7 +144,22 @@ export function planContinuation(pending, input, responseId) {
     const outputItems = toToolOutputItems(outputs);
     if (pending.length === 0) {
         const hasList = input.decisions !== undefined && input.decisions.length > 0;
+        // Both given is refused the same way planDecisions refuses it, regardless of pending state (#1254
+        // review): pending === 0 licenses only the P1 no-op, never a malformed pair of approval inputs.
+        if (hasList && input.decideAll !== undefined) {
+            throw new Error("Give either `decisions` or `decideAll` (exactly one): one decision per pending approval, or one for all. " +
+                "Answer relayed tool calls with `outputs`.");
+        }
         if (hasList) {
+            const seen = new Set();
+            const twice = new Set();
+            for (const d of input.decisions) {
+                if (seen.has(d.approvalId))
+                    twice.add(d.approvalId);
+                seen.add(d.approvalId);
+            }
+            if (twice.size)
+                throw new Error(`Approvals decided more than once: ${[...twice].join(", ")}`);
             throw new Error(`Not pending on ${responseId}: ${input.decisions.map((d) => d.approvalId).join(", ")}`);
         }
         return { outputs: outputItems, approvals: [] };
@@ -152,7 +167,7 @@ export function planContinuation(pending, input, responseId) {
     const hasApprovalInput = (input.decisions !== undefined && input.decisions.length > 0) || input.decideAll !== undefined;
     if (!hasApprovalInput) {
         throw new Error(`${responseId} also waits for approvals: every relayed tool call and every pending approval must be answered ` +
-            `in the same call as \`outputs\`. Undecided: ${pending.map((r) => r.id).join(", ")}`);
+            `in the same call as \`outputs\`. Undecided: ${pending.map((r) => String(r.id)).join(", ")}`);
     }
     return { outputs: outputItems, approvals: planDecisions(pending, input, responseId) };
 }
@@ -192,7 +207,10 @@ export function decideErrorText(error) {
     const text = formatErrorForMcp(error);
     if (!(error instanceof BackboneApiError))
         return text;
-    const hint = RELAY_ERROR_HINTS[error.errorType];
+    // hasOwn: an errorType named after an Object.prototype key (e.g. "toString") must not resolve to
+    // an inherited member — the gateway's error code is server-controlled, but never trusted as a key
+    // into a plain object (#1254 review; same guard as chatUrlFor in agent-run.ts).
+    const hint = Object.hasOwn(RELAY_ERROR_HINTS, error.errorType) ? RELAY_ERROR_HINTS[error.errorType] : undefined;
     return hint ? `${text}\nHint: ${hint}` : text;
 }
 //# sourceMappingURL=agent-decide.js.map

package/dist/lib/agent-run.d.ts

@@ -2,7 +2,9 @@
  * The run envelope of `bb agents run --json` (spec 2026-09-14-cli-agents-design.md §4.3), copied
  * from `cli/src/lib/agent-run.ts` because cli/ and mcp/ share no package (#667). Keep the two in step;
  * only the text of `next` differs, because an MCP caller decides through a tool, not a shell command.
+ * The connect pause is not copied by hand: `connect-pause.ts` is a guarded byte copy of the CLI's (#1086).
  */
+import { DEFAULT_CHAT_URL } from "./connect-pause.js";
 type AnyRecord = Record<string, any>;
 export type RunStatus = "completed" | "requires_approval" | "requires_tool_output" | "incomplete";
 export interface PendingApproval {
@@ -38,11 +40,11 @@ export interface PendingConnection {
     /** The egress difference an allow is re-asked for; absent otherwise. */
     destinations?: string[];
 }
-/** Fallback chat.2kw.ai origin when the API host is not one we recognise. */
-export declare const DEFAULT_CHAT_URL = "https://chat.2kw.ai";
+export { DEFAULT_CHAT_URL };
 /**
  * The chat web host that belongs to the server's API base URL (`AI_2KW_BASE_URL`), where a member
- * connects a connector. `AI_2KW_CHAT_URL` overrides the mapping; a trailing slash is dropped.
+ * connects a connector. `AI_2KW_CHAT_URL` overrides the mapping; a trailing slash is dropped. The
+ * mapping itself is the shared `connect-pause.ts`'s {@link chatOriginFor} (#1086).
  */
 export declare function chatUrlFor(baseUrl: string | undefined, env?: NodeJS.ProcessEnv): string;
 /** The end user's conversation mode (epic &59); the server matches these three values exactly. */
@@ -120,5 +122,4 @@ export declare function parseAgentModel(model?: string): {
  *   Connectors page.
  */
 export declare function buildRunEnvelope(result: ResponsesResult | undefined, agentRef?: string, chatUrl?: string): RunEnvelope;
-export {};
 //# sourceMappingURL=agent-run.d.ts.map

package/dist/lib/agent-run.js

@@ -2,33 +2,20 @@
  * The run envelope of `bb agents run --json` (spec 2026-09-14-cli-agents-design.md §4.3), copied
  * from `cli/src/lib/agent-run.ts` because cli/ and mcp/ share no package (#667). Keep the two in step;
  * only the text of `next` differs, because an MCP caller decides through a tool, not a shell command.
+ * The connect pause is not copied by hand: `connect-pause.ts` is a guarded byte copy of the CLI's (#1086).
  */
-/** Fallback chat.2kw.ai origin when the API host is not one we recognise. */
-export const DEFAULT_CHAT_URL = "https://chat.2kw.ai";
-/** Known API-host → chat web host mappings, as the CLI's `CHAT_URL_BY_API_HOST` (#807 R11). */
-const CHAT_URL_BY_API_HOST = {
-    "api.2kw.ai": "https://chat.2kw.ai",
-    "api-dev.2kw.ai": "https://chat-dev.2kw.ai",
-    "backbone.manfred-kunze.dev": "https://chat.2kw.ai",
-    "localhost:8080": "http://localhost:3000",
-    "127.0.0.1:8080": "http://localhost:3000",
-};
+import { chatOriginFor, connectCallIds, connectionsPhrase, DEFAULT_CHAT_URL, pendingConnectionsOf, } from "./connect-pause.js";
+export { DEFAULT_CHAT_URL };
 /**
  * The chat web host that belongs to the server's API base URL (`AI_2KW_BASE_URL`), where a member
- * connects a connector. `AI_2KW_CHAT_URL` overrides the mapping; a trailing slash is dropped.
+ * connects a connector. `AI_2KW_CHAT_URL` overrides the mapping; a trailing slash is dropped. The
+ * mapping itself is the shared `connect-pause.ts`'s {@link chatOriginFor} (#1086).
  */
 export function chatUrlFor(baseUrl, env = process.env) {
     const override = env.AI_2KW_CHAT_URL?.trim();
     if (override)
         return override.replace(/\/+$/, "");
-    try {
-        const host = new URL(baseUrl ?? "").host;
-        // hasOwn: a host named after an Object.prototype key must not resolve.
-        return Object.hasOwn(CHAT_URL_BY_API_HOST, host) ? CHAT_URL_BY_API_HOST[host] : DEFAULT_CHAT_URL;
-    }
-    catch {
-        return DEFAULT_CHAT_URL;
-    }
+    return chatOriginFor(baseUrl);
 }
 export const CONVERSATION_MODES = ["plan", "ask", "auto"];
 /**
@@ -94,46 +81,6 @@ function parseArguments(raw) {
         return raw;
     }
 }
-/** An open connector consent request; a continuation's projection carries another status. */
-function isOpenConnectRequest(item) {
-    return item.type === "backbone:connector_auth_request" && (item.status === undefined || item.status === "in_progress");
-}
-function pendingConnectionsOf(output) {
-    return output.filter(isOpenConnectRequest).map((i) => ({
-        serverLabel: String(i.server_label),
-        host: String(i.host),
-        reason: String(i.reason),
-        ...(Array.isArray(i.destinations) && i.destinations.length > 0
-            ? { destinations: i.destinations.map((d) => String(d)) }
-            : {}),
-    }));
-}
-/**
- * The call ids a connect pause withholds from the caller: the call each request names, and every
- * `mcp__<label>__connect` call for a pending connector (one request stands for all of them).
- */
-function connectCallIds(output, connections) {
-    const connectNames = new Set(connections.map((c) => `mcp__${c.serverLabel}__connect`));
-    const ids = new Set();
-    for (const item of output) {
-        if (isOpenConnectRequest(item) || (item.type === "function_call" && connectNames.has(String(item.name)))) {
-            ids.add(String(item.call_id));
-        }
-    }
-    return ids;
-}
-function connectionPhrase(c) {
-    const target = `${c.serverLabel} (${c.host})`;
-    if (c.reason === "allow")
-        return `allow the agent to use ${target}`;
-    if (c.reason === "reconnect")
-        return `reconnect ${target}`;
-    return `connect ${target}`;
-}
-function connectionsPhrase(connections) {
-    const phrases = connections.map(connectionPhrase);
-    return phrases.length > 1 ? `${phrases.slice(0, -1).join(", ")} and ${phrases.at(-1)}` : phrases[0] ?? "";
-}
 /**
  * Output item types the envelope decodes, or that never hold a run: text, reasoning and finished
  * connector calls. A pause on anything else (a connector approval's `mcp_approval_request`) is named.
@@ -160,8 +107,12 @@ function relayNext(pendingToolCalls, ref, responseId) {
         `Then call 2kw_decide_agent_approvals with agent ${JSON.stringify(ref)}, responseId ${JSON.stringify(responseId)} and one ` +
         "`outputs` entry per call.");
 }
+/** Output item types this server does not decode into anything the envelope shows (e.g. a connector-tool approval's `mcp_approval_request`). */
+function extraUndecodedTypes(output) {
+    return [...new Set(output.map((i) => String(i.type)).filter((t) => !DECODED_ITEM_TYPES.has(t)))];
+}
 function undecodedPause(output) {
-    const types = [...new Set(output.map((i) => String(i.type)).filter((t) => !DECODED_ITEM_TYPES.has(t)))];
+    const types = extraUndecodedTypes(output);
     return types.length > 0
         ? `This server cannot show or answer ${types.join(", ")}.`
         : "This server cannot tell what the run waits for.";
@@ -193,8 +144,15 @@ export function buildRunEnvelope(result, agentRef, chatUrl = DEFAULT_CHAT_URL) {
         policyClass: String(i.policy_class),
         reason: typeof i.reason === "string" && i.reason ? i.reason : null,
     }));
-    const pendingConnections = pendingConnectionsOf(output);
-    const withheldCallIds = new Set([...pendingApprovals.map((a) => a.callId), ...connectCallIds(output, pendingConnections)]);
+    // The one decoding rule (#1086): only an open request with its id, call id, label and host.
+    const connectRequests = pendingConnectionsOf(output);
+    const pendingConnections = connectRequests.map(({ serverLabel, host, reason, destinations }) => ({
+        serverLabel,
+        host,
+        reason,
+        ...(destinations ? { destinations } : {}),
+    }));
+    const withheldCallIds = new Set([...pendingApprovals.map((a) => a.callId), ...connectCallIds(output, connectRequests)]);
     const toolCalls = [];
     const pendingToolCalls = [];
     for (const item of output) {
@@ -238,17 +196,35 @@ export function buildRunEnvelope(result, agentRef, chatUrl = DEFAULT_CHAT_URL) {
         // The engine answers a connect call itself on the continuation, so connecting first is enough
         // to also resolve a relay + connect pause (#1254 M7).
         const relay = relayNext(pendingToolCalls, ref, responseId);
+        // The relay window started at the pause, not at the connection (#1254 review): connecting takes
+        // however long it takes, and does not reset the clock the relay text below names.
         const connectPrefix = pendingConnections.length > 0
-            ? `Tell the user to ${connectionsPhrase(pendingConnections)} in ${chatUrl}/connectors; once they have, continue as follows. `
+            ? `Tell the user to ${connectionsPhrase(pendingConnections)} in ${chatUrl}/connectors; once they have, continue as follows ` +
+                "without delay — the window below started at the pause, not at the connection. "
+            : "";
+        // Never a decideAll hint: the assistant decides only what the user decided (D12, #667). The
+        // approval also has to fit inside the relay window named above (#1254 review).
+        const approvalsSuffix = pendingApprovals.length > 0
+            ? " Show the pending approvals to the user and pass their decisions in the same call, within the same window."
+            : "";
+        // A connector-tool approval (mcp_approval_request) never decodes into pendingApprovals, so this
+        // envelope can under-report what is actually pending; say so rather than sound falsely complete
+        // (#1254 review). The continuation itself still refuses an incomplete answer (400
+        // incomplete_tool_outputs, decideErrorText's hint), this only tells the assistant to expect that.
+        const undecodedTypes = extraUndecodedTypes(output);
+        const undecodedSuffix = undecodedTypes.length > 0
+            ? ` This server also cannot show or answer ${undecodedTypes.join(", ")} on this response — it may hold more than ` +
+                "the relayed calls above (for example another pending approval); if the continuation answers " +
+                "400 incomplete_tool_outputs, that is why."
             : "";
-        // Never a decideAll hint: the assistant decides only what the user decided (D12, #667).
-        const approvalsSuffix = pendingApprovals.length > 0 ? " Show the pending approvals to the user and pass their decisions in the same call." : "";
-        next = `${connectPrefix}${relay}${approvalsSuffix}`;
+        next = `${connectPrefix}${relay}${approvalsSuffix}${undecodedSuffix}`;
     }
     else if (status === "requires_tool_output" && pendingConnections.length > 0 && pendingToolCalls.length === 0 && responseId) {
-        // No tool here takes previous_response_id, and a connect pause cannot be continued by
-        // conversation (the gateway answers 400), so the honest ways on are a fresh request or a
-        // client that continues by response id.
+        // A connector-only pause (no relayed call, so 2kw_decide_agent_approvals has nothing to decide,
+        // spec M11) has no tool here to continue it by id, and a connect pause cannot be continued by
+        // conversation (the gateway answers 400), so the honest ways on are a fresh request or a client
+        // that continues by response id (#1254 review: continueWithDecisions does send previous_response_id
+        // for every other pause this server can decide).
         next =
             `Tell the user to ${connectionsPhrase(pendingConnections)} in ${chatUrl}/connectors. ` +
                 `This server cannot continue response ${JSON.stringify(responseId)}: once they have connected, send the request again ` +

package/dist/lib/connect-pause.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The connect pause, decoded one way for every client (#1086, spec §4, D4): an open
+ * `backbone:connector_auth_request` (#807 R12) is a connector the run waits for the user to
+ * connect, allow or reconnect in chat.2kw.ai.
+ *
+ * This file is canonical. `mcp/src/lib/connect-pause.ts` and
+ * `n8n/nodes/TwoKw/operations/connect-pause.ts` are byte copies of it under a header: edit it
+ * here, then run `npm run sync:connect-pause` in mcp/ and `npm run sync-connect-pause` in n8n/.
+ * Its golden fixture, `cli/tests/fixtures/connect-pause-cases.json`, is copied the same way into
+ * mcp/, n8n/ and surface/, and every client's decoder test runs every case of it.
+ *
+ * Plain TypeScript with no imports, no `process`, no Node types and no timers, so n8n's source
+ * scanner and its empty `dependencies` accept the copy. The CLI and the MCP server keep their
+ * `AI_2KW_CHAT_URL` override in their own code, around {@link chatOriginFor}.
+ */
+/** Fallback chat.2kw.ai origin when the API host is not one we recognise. */
+export declare const DEFAULT_CHAT_URL = "https://chat.2kw.ai";
+/** Known API-host → chat web host mappings; a connect pause points the user there (#807 R11). */
+export declare const CHAT_URL_BY_API_HOST: Readonly<Record<string, string>>;
+/**
+ * The chat web host that belongs to an API base URL, where a member connects a connector
+ * (`<chat>/connectors`). An unknown host, an unparsable URL or no URL at all is chat.2kw.ai.
+ */
+export declare function chatOriginFor(baseUrl: unknown): string;
+/** What the user is asked to do: connect, allow the agent, or reconnect. */
+export type ConnectReason = "connect" | "allow" | "reconnect";
+export declare const CONNECT_REASONS: readonly ConnectReason[];
+/**
+ * One open connect request. `id` (`cauth_<call id>`) and `callId` (the first connect call for
+ * this connector) are what a client needs to withhold the connect calls; the CLI and the MCP
+ * server drop both from what they publish.
+ */
+export interface PendingConnection {
+    id: string;
+    callId: string;
+    serverLabel: string;
+    /** The MCP server's host: what the user is asked to connect to. */
+    host: string;
+    reason: ConnectReason;
+    /** The egress difference an allow is asked again for (#807 R9); absent otherwise, never empty. */
+    destinations?: string[];
+}
+/** Enough of a connection to name it in a sentence. */
+export interface ConnectTarget {
+    serverLabel: string;
+    host: string;
+    reason: string;
+}
+/** The synthetic tool a connector's connect pause is raised through (#806). */
+export declare function connectToolName(serverLabel: string): string;
+/**
+ * The connectors a response's `output` still waits on: every `in_progress` connect request whose
+ * id no other-status projection in the same list resolved, one per id, in order. An item without
+ * a non-empty `id`, `call_id`, `server_label` or `host` cannot be acted on and is skipped; a
+ * `reason` outside the three reads as `connect`, the action that always applies; only the string
+ * entries of `destinations` are kept, and none at all omits the field.
+ */
+export declare function pendingConnectionsOf(output: unknown): PendingConnection[];
+/**
+ * The call ids a connect pause withholds from the caller: the call each pending request names;
+ * the own `call_id` of every open connect request, even one {@link pendingConnectionsOf} could not
+ * describe (a missing `server_label` or `host`), since a connect call is the engine's to answer,
+ * never the client's (R7); and every `mcp__<label>__connect` call for a connector in
+ * `connections` (the model may call it more than once; one request stands for all of them).
+ */
+export declare function connectCallIds(output: unknown, connections: readonly Pick<PendingConnection, "callId" | "serverLabel">[]): Set<string>;
+/** "connect erp (erp.example.com)", "allow the agent to use …" or "reconnect …". */
+export declare function connectionPhrase(c: ConnectTarget): string;
+/** "connect a (h), allow the agent to use b (h) and reconnect c (h)"; empty for none. */
+export declare function connectionsPhrase(connections: readonly ConnectTarget[]): string;
+//# sourceMappingURL=connect-pause.d.ts.map

package/dist/lib/connect-pause.js

@@ -0,0 +1,149 @@
+// GENERATED COPY of cli/src/lib/connect-pause.ts (#1086). Do not edit here: edit the CLI's file,
+// then run `npm run sync:connect-pause` in mcp/. `npm run check:connect-pause` fails on any drift.
+/**
+ * The connect pause, decoded one way for every client (#1086, spec §4, D4): an open
+ * `backbone:connector_auth_request` (#807 R12) is a connector the run waits for the user to
+ * connect, allow or reconnect in chat.2kw.ai.
+ *
+ * This file is canonical. `mcp/src/lib/connect-pause.ts` and
+ * `n8n/nodes/TwoKw/operations/connect-pause.ts` are byte copies of it under a header: edit it
+ * here, then run `npm run sync:connect-pause` in mcp/ and `npm run sync-connect-pause` in n8n/.
+ * Its golden fixture, `cli/tests/fixtures/connect-pause-cases.json`, is copied the same way into
+ * mcp/, n8n/ and surface/, and every client's decoder test runs every case of it.
+ *
+ * Plain TypeScript with no imports, no `process`, no Node types and no timers, so n8n's source
+ * scanner and its empty `dependencies` accept the copy. The CLI and the MCP server keep their
+ * `AI_2KW_CHAT_URL` override in their own code, around {@link chatOriginFor}.
+ */
+/** Fallback chat.2kw.ai origin when the API host is not one we recognise. */
+export const DEFAULT_CHAT_URL = "https://chat.2kw.ai";
+/** Known API-host → chat web host mappings; a connect pause points the user there (#807 R11). */
+export const CHAT_URL_BY_API_HOST = {
+    "api.2kw.ai": "https://chat.2kw.ai",
+    "api-dev.2kw.ai": "https://chat-dev.2kw.ai",
+    "backbone.manfred-kunze.dev": "https://chat.2kw.ai",
+    "localhost:8080": "http://localhost:3000",
+    "127.0.0.1:8080": "http://localhost:3000",
+};
+/**
+ * The chat web host that belongs to an API base URL, where a member connects a connector
+ * (`<chat>/connectors`). An unknown host, an unparsable URL or no URL at all is chat.2kw.ai.
+ */
+export function chatOriginFor(baseUrl) {
+    try {
+        const host = new URL(String(baseUrl ?? "")).host;
+        // hasOwn, not a bare index: a host named after an Object.prototype key must not resolve.
+        return Object.hasOwn(CHAT_URL_BY_API_HOST, host) ? CHAT_URL_BY_API_HOST[host] ?? DEFAULT_CHAT_URL : DEFAULT_CHAT_URL;
+    }
+    catch {
+        return DEFAULT_CHAT_URL;
+    }
+}
+export const CONNECT_REASONS = ["connect", "allow", "reconnect"];
+const CONNECT_REQUEST = "backbone:connector_auth_request";
+function itemsOf(output) {
+    if (!Array.isArray(output))
+        return [];
+    return output.filter((item) => typeof item === "object" && item !== null && !Array.isArray(item));
+}
+function text(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+/** The synthetic tool a connector's connect pause is raised through (#806). */
+export function connectToolName(serverLabel) {
+    return `mcp__${serverLabel}__connect`;
+}
+/**
+ * The connectors a response's `output` still waits on: every `in_progress` connect request whose
+ * id no other-status projection in the same list resolved, one per id, in order. An item without
+ * a non-empty `id`, `call_id`, `server_label` or `host` cannot be acted on and is skipped; a
+ * `reason` outside the three reads as `connect`, the action that always applies; only the string
+ * entries of `destinations` are kept, and none at all omits the field.
+ */
+export function pendingConnectionsOf(output) {
+    const items = itemsOf(output);
+    const resolved = new Set();
+    for (const item of items) {
+        const id = text(item.id);
+        if (item.type === CONNECT_REQUEST && id && item.status !== "in_progress")
+            resolved.add(id);
+    }
+    const pending = new Map();
+    for (const item of items) {
+        if (item.type !== CONNECT_REQUEST || item.status !== "in_progress")
+            continue;
+        const id = text(item.id);
+        const callId = text(item.call_id);
+        const serverLabel = text(item.server_label);
+        const host = text(item.host);
+        if (!id || !callId || !serverLabel || !host || resolved.has(id) || pending.has(id))
+            continue;
+        const reason = text(item.reason);
+        const destinations = Array.isArray(item.destinations)
+            ? item.destinations.filter((entry) => typeof entry === "string")
+            : [];
+        pending.set(id, {
+            id,
+            callId,
+            serverLabel,
+            host,
+            reason: reason && CONNECT_REASONS.includes(reason) ? reason : "connect",
+            ...(destinations.length > 0 ? { destinations } : {}),
+        });
+    }
+    return [...pending.values()];
+}
+/**
+ * The call ids a connect pause withholds from the caller: the call each pending request names;
+ * the own `call_id` of every open connect request, even one {@link pendingConnectionsOf} could not
+ * describe (a missing `server_label` or `host`), since a connect call is the engine's to answer,
+ * never the client's (R7); and every `mcp__<label>__connect` call for a connector in
+ * `connections` (the model may call it more than once; one request stands for all of them).
+ */
+export function connectCallIds(output, connections) {
+    const names = new Set(connections.map((c) => connectToolName(c.serverLabel)));
+    const ids = new Set(connections.map((c) => c.callId));
+    const items = itemsOf(output);
+    // Every open connect request's own call id is withheld, even one pendingConnectionsOf could
+    // not fully describe (a missing server_label or host): the paired function_call must never be
+    // left for the caller to fabricate an output for (R7).
+    const resolved = new Set();
+    for (const item of items) {
+        const id = text(item.id);
+        if (item.type === CONNECT_REQUEST && id && item.status !== "in_progress")
+            resolved.add(id);
+    }
+    for (const item of items) {
+        if (item.type !== CONNECT_REQUEST || item.status !== "in_progress")
+            continue;
+        const id = text(item.id);
+        if (id && resolved.has(id))
+            continue;
+        const callId = text(item.call_id);
+        if (callId)
+            ids.add(callId);
+    }
+    for (const item of items) {
+        const callId = text(item.call_id);
+        if (item.type === "function_call" && callId && typeof item.name === "string" && names.has(item.name))
+            ids.add(callId);
+    }
+    return ids;
+}
+/** "connect erp (erp.example.com)", "allow the agent to use …" or "reconnect …". */
+export function connectionPhrase(c) {
+    const target = `${c.serverLabel} (${c.host})`;
+    if (c.reason === "allow")
+        return `allow the agent to use ${target}`;
+    if (c.reason === "reconnect")
+        return `reconnect ${target}`;
+    return `connect ${target}`;
+}
+/** "connect a (h), allow the agent to use b (h) and reconnect c (h)"; empty for none. */
+export function connectionsPhrase(connections) {
+    const phrases = connections.map(connectionPhrase);
+    if (phrases.length < 2)
+        return phrases[0] ?? "";
+    return `${phrases.slice(0, -1).join(", ")} and ${phrases[phrases.length - 1]}`;
+}
+//# sourceMappingURL=connect-pause.js.map

package/dist/tools/agents.js

@@ -555,13 +555,14 @@ export function register(server, client) {
         + "to the user first and run it only after they agree; never pass the arguments unchecked into a shell or another tool. "
         + "Otherwise answer it with `failed: true` and output \"not available in this client\". Answer within one hour of the pause. "
         + "Pass `agent` exactly as the run was started (keep '@label' and '#model'). "
-        + "Returns the continuation's run envelope, which can pause again: for approval, or on a connector the user must connect "
-        + "in chat.2kw.ai → Connectors (`pendingConnections`; follow its `next`)."
+        + "Returns the continuation's run envelope, which can pause again: for approval, on another relayed tool call (answer it the "
+        + "same way), or on a connector the user must connect in chat.2kw.ai → Connectors (`pendingConnections`; follow its `next`)."
         + " " + MODE_RULE, {
         agent: z.string().min(1).describe("Agent id or name as the run used it: 'ref[@label][#model]'"),
         responseId: z.string().min(1).describe("The paused response's id (envelope `responseId`)"),
         outputs: z
-            .array(z.object({
+            .array(z
+            .object({
             callId: z.string().min(1).describe("Envelope `pendingToolCalls[].callId`"),
             output: z
                 .string()
@@ -570,17 +571,22 @@ export function register(server, client) {
                 .boolean()
                 .optional()
                 .describe("The call failed or was declined: the tool's span ends ERROR and the agent sees `output` as the error"),
-        }))
+        })
+            // Strict: an unrecognized key (e.g. `error`/`isError`/`status` instead of `failed`) must
+            // refuse the call, not silently drop the very field that tells the tool's span ERROR (#1254 review).
+            .strict())
             .optional()
             .describe("One entry per relayed tool call of the paused response (envelope `pendingToolCalls`), within one hour of the pause. " +
             "Combine with `decisions` or `decideAll` when approvals are pending too."),
         decisions: z
-            .array(z.object({
+            .array(z
+            .object({
             approvalId: z.string().min(1).describe("Envelope `pendingApprovals[].approvalId`"),
             decision: z.enum(["approve", "reject"]),
             reason: z.string().optional().describe("Stored with the decision; the model sees it on a reject"),
             remember: z.boolean().optional().describe("Approve this tool for the rest of the conversation; not on destructive tools"),
-        }))
+        })
+            .strict())
             .optional()
             .describe("One entry per pending approval. Mutually exclusive with `decideAll`."),
         decideAll: z.enum(["approve", "reject"]).optional().describe("Decide every pending approval the same way"),

package/dist/tools/index.js

@@ -35,7 +35,7 @@ export const TOOL_GROUPS = [
     {
         id: "agents",
         title: "Agents",
-        summary: "Manage agents, their versions, labels and tool catalogs, and decide paused approvals. See [Running agents](#running-agents).",
+        summary: "Manage agents, their versions, labels and tool catalogs, and decide a paused run's approvals and relayed tool calls. See [Running agents](#running-agents).",
         register: (s, d) => agents.register(s, d.client),
     },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2kw/ai-mcp-server",
-  "version": "6.3.0-dev.117",
+  "version": "6.3.0-dev.118",
   "description": "MCP server for 2kw.ai — EU-hosted AI platform: OpenAI-compatible LLM gateway, schema-driven document extraction, transcription, agents with a knowledge base, and cost observability. 158 tools for Claude Code, Cursor, and Windsurf.",
   "mcpName": "ai.2kw/mcp-server",
   "keywords": [
@@ -43,6 +43,8 @@
     "check:coverage": "tsx ../cli/openapi/scripts/check-coverage.ts",
     "docs:tools": "tsx scripts/tool-docs.ts",
     "check:tool-docs": "tsx scripts/tool-docs.ts --check",
+    "sync:connect-pause": "tsx scripts/sync-connect-pause.ts",
+    "check:connect-pause": "tsx scripts/sync-connect-pause.ts --check",
     "test": "tsx --test tests/*.test.ts",
     "typecheck": "tsc --noEmit"
   },