@2kw/ai-mcp-server 7.0.0-dev.4 → 7.0.0-dev.8

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

@@ -5,7 +5,7 @@
  * The connect pause is not copied by hand: `connect-pause.ts` is a guarded byte copy of the CLI's (#1086).
  */
 import type { components } from "../generated/openapi.js";
-import { DEFAULT_CHAT_URL } from "./connect-pause.js";
+import { DEFAULT_CHAT_URL, type InputMode } from "./connect-pause.js";
 type AnyRecord = Record<string, any>;
 export type RunStatus = "completed" | "requires_approval" | "requires_tool_output" | "incomplete";
 /** A built-in SkillsApply approval's preview (#781, spec §6); the generated type, fields all optional. */
@@ -52,6 +52,19 @@ export { DEFAULT_CHAT_URL };
  * mapping itself is the shared `connect-pause.ts`'s {@link chatOriginFor} (#1086).
  */
 export declare function chatUrlFor(baseUrl: string | undefined, env?: NodeJS.ProcessEnv): string;
+/**
+ * A connector's question the run waits on (#1320, connectors spec §12): an open
+ * `backbone:input_request`. Only the user who started the run answers it, and only in chat, at
+ * `answerUrl`; the envelope never carries the question, its form or its link (D7).
+ */
+export interface PendingInput {
+    inputRequestId: string;
+    serverLabel: string;
+    tool: string;
+    /** `form`, `url`, `mixed` (both) or `unknown`: what the user does in chat. */
+    mode: InputMode;
+    answerUrl: string;
+}
 /** The end user's conversation mode (epic &59); the server matches these three values exactly. */
 export type ConversationMode = "plan" | "ask" | "auto";
 export declare const CONVERSATION_MODES: readonly ConversationMode[];
@@ -83,6 +96,7 @@ export interface RunEnvelope {
     pendingApprovals: PendingApproval[];
     pendingToolCalls: PendingToolCall[];
     pendingConnections: PendingConnection[];
+    pendingInputs: PendingInput[];
     incompleteReason: string | null;
     usage: {
         inputTokens: number;

package/dist/lib/agent-run.js

@@ -1,4 +1,4 @@
-import { chatOriginFor, connectCallIds, connectionsPhrase, DEFAULT_CHAT_URL, pendingConnectionsOf, } from "./connect-pause.js";
+import { answerUrlFor, chatOriginFor, connectCallIds, connectionsPhrase, DEFAULT_CHAT_URL, inputLabelsPhrase, pendingConnectionsOf, pendingInputsOf, } 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
@@ -104,6 +104,7 @@ const DECODED_ITEM_TYPES = new Set([
     "function_call_output",
     "backbone:approval_request",
     "backbone:connector_auth_request",
+    "backbone:input_request",
     "backbone:tool_image",
     "mcp_approval_request",
     "mcp_call",
@@ -170,7 +171,22 @@ export function buildRunEnvelope(result, agentRef, chatUrl = DEFAULT_CHAT_URL) {
         reason,
         ...(destinations ? { destinations } : {}),
     }));
-    const withheldCallIds = new Set([...pendingApprovals.map((a) => a.callId), ...connectCallIds(output, connectRequests)]);
+    // A connector's question (#1320): answered in chat only, so the envelope names where, never what (D7).
+    const inputRequests = pendingInputsOf(output);
+    const answerUrl = answerUrlFor(chatUrl, result?.conversation?.id ?? null);
+    const pendingInputs = inputRequests.map(({ id, serverLabel, tool, mode }) => ({
+        inputRequestId: id,
+        serverLabel,
+        tool,
+        mode,
+        answerUrl,
+    }));
+    const withheldCallIds = new Set([
+        ...pendingApprovals.map((a) => a.callId),
+        ...connectCallIds(output, connectRequests),
+        // An awaiting call has no function_call item (spec §5); withheld all the same, never the caller's to answer.
+        ...inputRequests.map((i) => i.callId),
+    ]);
     const toolCalls = [];
     const pendingToolCalls = [];
     for (const item of output) {
@@ -194,9 +210,10 @@ export function buildRunEnvelope(result, agentRef, chatUrl = DEFAULT_CHAT_URL) {
             status = "incomplete";
             break;
         case "requires_action":
-            // A connect pause is requires_tool_output too (#807 R12): no tool here can answer it.
+            // A connect pause is requires_tool_output too (#807 R12): no tool here can answer it, nor an
+            // input pause, which outranks every other (#1320, P91).
             status =
-                pendingToolCalls.length > 0 || pendingConnections.length > 0 || pendingApprovals.length === 0
+                pendingInputs.length > 0 || pendingToolCalls.length > 0 || pendingConnections.length > 0 || pendingApprovals.length === 0
                     ? "requires_tool_output"
                     : "requires_approval";
             break;
@@ -206,7 +223,17 @@ export function buildRunEnvelope(result, agentRef, chatUrl = DEFAULT_CHAT_URL) {
     const responseId = result?.id ?? null;
     const ref = agentRef ?? agent;
     let next = null;
-    if (status === "requires_approval" && ref && responseId) {
+    if (pendingInputs.length > 0) {
+        // Only the requester's continuation resolves the response (spec D9), and only chat sends one: no
+        // tool here continues it, whatever else waits (#1320, P91). The question is the server's text for
+        // the user, never for the assistant (D7), so the assistant is told not to collect the answer.
+        const labels = inputLabelsPhrase(pendingInputs);
+        const needs = new Set(pendingInputs.map((i) => i.serverLabel)).size > 1 ? "need" : "needs";
+        next =
+            `Tell the user that ${labels} ${needs} their input and that they answer in chat: ${answerUrl}. ` +
+                "No tool here can answer it, and the run continues in chat. Do not ask the user for the answer here.";
+    }
+    else if (status === "requires_approval" && ref && responseId) {
         // Never an "approve all" hint: the assistant decides only what the user decided (D12).
         next = `Show the pending approvals to the user; after they decide each one, call 2kw_decide_agent_approvals with agent ${JSON.stringify(ref)} and responseId ${JSON.stringify(responseId)}.`;
     }
@@ -275,6 +302,7 @@ export function buildRunEnvelope(result, agentRef, chatUrl = DEFAULT_CHAT_URL) {
         pendingApprovals,
         pendingToolCalls,
         pendingConnections,
+        pendingInputs,
         incompleteReason: result?.incomplete_details?.reason ?? null,
         usage: result?.usage
             ? { inputTokens: result.usage.input_tokens ?? 0, outputTokens: result.usage.output_tokens ?? 0 }

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

@@ -7,7 +7,8 @@
  * `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.
+ * mcp/, n8n/ and surface/, and every client's decoder test runs every case of it. The input pause
+ * (#1320, connectors spec §12) lives here too, with its own fixture `input-pause-cases.json`.
  *
  * 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
@@ -68,4 +69,37 @@ export declare function connectCallIds(output: unknown, connections: readonly Pi
 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;
+/**
+ * What an open input request asks for: a form, a page to open, both (`mixed`), or neither of the
+ * modes this client knows (`unknown`). It names no URL: the question stays in chat (D7).
+ */
+export type InputMode = "form" | "url" | "mixed" | "unknown";
+/**
+ * One open `backbone:input_request` (#1320, connectors spec §12): a connector's question that only
+ * the requester can answer, and only in chat. `id` is the item's `inreq_…` id. Its message, schema
+ * and URL are never read: no assistant may see them (D7).
+ */
+export interface PendingInput {
+    id: string;
+    callId: string;
+    serverLabel: string;
+    /** The tool's own name, without the `mcp__<label>__` prefix. */
+    tool: string;
+    mode: InputMode;
+}
+/**
+ * The questions a response's `output` still waits on, in order, by the chat's own rule
+ * (`surface/src/core/chat.ts`, so a link never points at a question the chat would not show): an
+ * `in_progress` request whose id no other-status projection and no `backbone:input_response`
+ * resolved, and only the newest open round of its call. An item without a non-empty `id`,
+ * `call_id`, `server_label` or `name`, or without one request entry that has a `key`, is skipped.
+ */
+export declare function pendingInputsOf(output: unknown): PendingInput[];
+/**
+ * Where the user answers: the chat's slug-less conversation link (`<chat>/c/<id>`, the path
+ * `surface/src/hosts/web/routes.ts` `answerPath` builds), or the chat itself without a conversation.
+ */
+export declare function answerUrlFor(chatOrigin: string, conversationId: string | null | undefined): string;
+/** "erp", "erp and crm", "erp, crm and drive": each connector that asks, once; empty for none. */
+export declare function inputLabelsPhrase(inputs: readonly Pick<PendingInput, "serverLabel">[]): string;
 //# sourceMappingURL=connect-pause.d.ts.map

package/dist/lib/connect-pause.js

@@ -9,7 +9,8 @@
  * `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.
+ * mcp/, n8n/ and surface/, and every client's decoder test runs every case of it. The input pause
+ * (#1320, connectors spec §12) lives here too, with its own fixture `input-pause-cases.json`.
  *
  * 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
@@ -146,4 +147,77 @@ export function connectionsPhrase(connections) {
         return phrases[0] ?? "";
     return `${phrases.slice(0, -1).join(", ")} and ${phrases[phrases.length - 1]}`;
 }
+const INPUT_REQUEST = "backbone:input_request";
+const INPUT_RESPONSE = "backbone:input_response";
+function roundOf(value) {
+    return typeof value === "number" && Number.isInteger(value) ? value : 1;
+}
+function inputModeOf(requests) {
+    const modes = new Set(requests.map((entry) => entry.mode).filter((mode) => mode === "form" || mode === "url"));
+    if (modes.size === 2)
+        return "mixed";
+    if (modes.has("form"))
+        return "form";
+    return modes.has("url") ? "url" : "unknown";
+}
+/**
+ * The questions a response's `output` still waits on, in order, by the chat's own rule
+ * (`surface/src/core/chat.ts`, so a link never points at a question the chat would not show): an
+ * `in_progress` request whose id no other-status projection and no `backbone:input_response`
+ * resolved, and only the newest open round of its call. An item without a non-empty `id`,
+ * `call_id`, `server_label` or `name`, or without one request entry that has a `key`, is skipped.
+ */
+export function pendingInputsOf(output) {
+    const items = itemsOf(output);
+    const resolved = new Set();
+    const newestRound = new Map();
+    for (const item of items) {
+        if (item.type === INPUT_REQUEST) {
+            const id = text(item.id);
+            if (id && item.status !== "in_progress")
+                resolved.add(id);
+            const callId = text(item.call_id);
+            if (callId && item.status === "in_progress") {
+                newestRound.set(callId, Math.max(newestRound.get(callId) ?? 0, roundOf(item.round)));
+            }
+        }
+        else if (item.type === INPUT_RESPONSE) {
+            const id = text(item.input_request_id);
+            if (id)
+                resolved.add(id);
+        }
+    }
+    const pending = new Map();
+    for (const item of items) {
+        if (item.type !== INPUT_REQUEST || item.status !== "in_progress")
+            continue;
+        const id = text(item.id);
+        const callId = text(item.call_id);
+        const serverLabel = text(item.server_label);
+        const tool = text(item.name);
+        if (!id || !callId || !serverLabel || !tool || resolved.has(id) || pending.has(id))
+            continue;
+        if (roundOf(item.round) !== newestRound.get(callId))
+            continue;
+        const requests = itemsOf(item.requests).filter((entry) => text(entry.key) !== undefined);
+        if (requests.length === 0)
+            continue;
+        pending.set(id, { id, callId, serverLabel, tool, mode: inputModeOf(requests) });
+    }
+    return [...pending.values()];
+}
+/**
+ * Where the user answers: the chat's slug-less conversation link (`<chat>/c/<id>`, the path
+ * `surface/src/hosts/web/routes.ts` `answerPath` builds), or the chat itself without a conversation.
+ */
+export function answerUrlFor(chatOrigin, conversationId) {
+    return conversationId ? `${chatOrigin}/c/${encodeURIComponent(conversationId)}` : `${chatOrigin}/`;
+}
+/** "erp", "erp and crm", "erp, crm and drive": each connector that asks, once; empty for none. */
+export function inputLabelsPhrase(inputs) {
+    const labels = [...new Set(inputs.map((input) => input.serverLabel))];
+    if (labels.length < 2)
+        return labels[0] ?? "";
+    return `${labels.slice(0, -1).join(", ")} and ${labels[labels.length - 1]}`;
+}
 //# sourceMappingURL=connect-pause.js.map

package/dist/tools/agents.js

@@ -556,7 +556,8 @@ export function register(server, client) {
         + "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, 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`)."
+        + "same way), or on a connector the user must connect in chat.2kw.ai → Connectors (`pendingConnections`; follow its `next`), "
+        + "or on a connector's question the user answers in chat (`pendingInputs`; 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`)"),

package/dist/tools/ai-gateway.js

@@ -93,7 +93,7 @@ export function register(server, client) {
         }
     });
     // ── create_response ─────────────────────────────────────────────────────
-    server.tool("2kw_create_response", "Send a request through Backbone's OpenAI-compatible OpenResponses endpoint (POST /v1/responses). Model format: 'provider/model' for a direct gateway call via `model`, or use `agent` to invoke a stored agent by id or name (optionally 'ref@label', e.g. 'support-bot@latest'). With `agent`, `agentModel` runs this one request on another model from the agent version's `models` list. With `agent`, the reply is the run envelope as JSON (status, text, tool calls, pending approvals, response id, next step) followed by the model that answered; answer an approval pause with 2kw_decide_agent_approvals. A run paused on a relayed (client-side) tool call comes back with status requires_tool_output and `pendingToolCalls`; answer it with 2kw_decide_agent_approvals `outputs`. A run that needs the user's own sign-in to a connector pauses with status requires_tool_output and `pendingConnections` (label, host, reason): no tool here can answer that; tell the user to connect it in chat.2kw.ai → Connectors, as the envelope's `next` says. Always non-streaming. " + MODE_RULE, {
+    server.tool("2kw_create_response", "Send a request through Backbone's OpenAI-compatible OpenResponses endpoint (POST /v1/responses). Model format: 'provider/model' for a direct gateway call via `model`, or use `agent` to invoke a stored agent by id or name (optionally 'ref@label', e.g. 'support-bot@latest'). With `agent`, `agentModel` runs this one request on another model from the agent version's `models` list. With `agent`, the reply is the run envelope as JSON (status, text, tool calls, pending approvals, response id, next step) followed by the model that answered; answer an approval pause with 2kw_decide_agent_approvals. A run paused on a relayed (client-side) tool call comes back with status requires_tool_output and `pendingToolCalls`; answer it with 2kw_decide_agent_approvals `outputs`. A run that needs the user's own sign-in to a connector pauses with status requires_tool_output and `pendingConnections` (label, host, reason): no tool here can answer that; tell the user to connect it in chat.2kw.ai → Connectors, as the envelope's `next` says. A run where a connector asks the user a question pauses with status requires_tool_output and `pendingInputs` (label, tool, mode, answerUrl): the user answers it in chat at `answerUrl`, not here. Always non-streaming. " + MODE_RULE, {
         input: z.string().min(1).describe("The input text (sent as a single user message)"),
         agent: z
             .string()

package/dist/tools/conversations.d.ts

@@ -1,4 +1,12 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { ApiClient } from "../client.js";
+/**
+ * A conversation's items as an assistant may read them (#1320, connectors spec D7): a connector's
+ * question is the server's text for the user, never for an assistant, so a `backbone:input_request`
+ * keeps each request's `key` and `mode` only (no message, schema or link) and a
+ * `backbone:input_response` keeps each answer's `action` only (no content). Every other item and
+ * field passes through unchanged.
+ */
+export declare function withoutInputContent(list: unknown): unknown;
 export declare function register(server: McpServer, client: ApiClient): void;
 //# sourceMappingURL=conversations.d.ts.map

package/dist/tools/conversations.js

@@ -1,5 +1,35 @@
 import { z } from "zod";
 import { formatErrorForMcp } from "../errors.js";
+const isItem = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+ * A conversation's items as an assistant may read them (#1320, connectors spec D7): a connector's
+ * question is the server's text for the user, never for an assistant, so a `backbone:input_request`
+ * keeps each request's `key` and `mode` only (no message, schema or link) and a
+ * `backbone:input_response` keeps each answer's `action` only (no content). Every other item and
+ * field passes through unchanged.
+ */
+export function withoutInputContent(list) {
+    if (!isItem(list) || !Array.isArray(list.data))
+        return list;
+    return {
+        ...list,
+        data: list.data.map((item) => {
+            if (!isItem(item))
+                return item;
+            if (item.type === "backbone:input_request" && Array.isArray(item.requests)) {
+                return {
+                    ...item,
+                    requests: item.requests.map((entry) => (isItem(entry) ? { key: entry.key, mode: entry.mode } : null)),
+                };
+            }
+            if (item.type === "backbone:input_response" && isItem(item.responses)) {
+                const responses = Object.fromEntries(Object.entries(item.responses).map(([key, answer]) => [key, isItem(answer) ? { action: answer.action } : null]));
+                return { ...item, responses };
+            }
+            return item;
+        }),
+    };
+}
 export function register(server, client) {
     // ── create_conversation ─────────────────────────────────────────────────
     server.tool("2kw_create_conversation", "Create a conversation whose id can be passed as the 'conversation' parameter on the responses API, so an agent turn can be replayed and extended across calls.", {
@@ -161,13 +191,13 @@ export function register(server, client) {
         }
     });
     // ── list_conversation_items ──────────────────────────────────────────────
-    server.tool("2kw_list_conversation_items", "Fetch a conversation's items in replay order, oldest first.", { conversationId: z.string().describe("The conversation ID") }, async ({ conversationId }) => {
+    server.tool("2kw_list_conversation_items", "Fetch a conversation's items in replay order, oldest first. A connector's question to the user and the user's answer are listed without their text: the user reads and answers them in chat.", { conversationId: z.string().describe("The conversation ID") }, async ({ conversationId }) => {
         try {
             const { data } = await client.GET("/v1/conversations/{conversationId}/items", {
                 params: { path: { conversationId } },
             });
             return {
-                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+                content: [{ type: "text", text: JSON.stringify(withoutInputContent(data), null, 2) }],
             };
         }
         catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2kw/ai-mcp-server",
-  "version": "7.0.0-dev.4",
+  "version": "7.0.0-dev.8",
   "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": [