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

package/dist/commands/agent-run.js

@@ -124,7 +124,7 @@ async function finishRun(command, client, target, first, opts) {
 }
 export function makeAgentRunCommand() {
     return new Command("run")
-        .description("Run an agent on a task (exit 3 = paused for approval, 4 = needs client tool output or a connector connected in chat, 5 = incomplete)")
+        .description("Run an agent on a task (exit 3 = paused for approval, 4 = needs client tool output, a connector connected in chat or your answer in chat, 5 = incomplete)")
         .argument("<agent>", "Agent name or id, optionally with @label and #model")
         .argument("[input]", "Task text (or use --input-file, or pipe it on stdin); optional with --continue")
         .option("--input-file <path>", "Read the task text from a file")

package/dist/commands/billing.js

@@ -4,6 +4,8 @@ import { isJsonOutput } from "../lib/config.js";
 import { CliUsageError } from "../lib/errors.js";
 import { formatDetail, formatList } from "../lib/output.js";
 import chalk from "chalk";
+/** What human output shows for a null tier: an organisation without a plan (#1356). */
+const NO_PLAN = "no plan";
 export function makeBillingCommand() {
     const cmd = new Command("billing").description("Billing and subscription management");
     cmd
@@ -23,7 +25,9 @@ export function makeBillingCommand() {
         await runAction(command, async () => {
             const client = getClient(command);
             const { data } = await client.GET("/v1/billing/tier");
-            formatDetail(data, command);
+            // A null name is an organisation without a plan (#1356); --json keeps the raw null.
+            const shown = data && data.name == null && !isJsonOutput(command) ? { ...data, name: NO_PLAN } : data;
+            formatDetail(shown, command);
         });
     });
     cmd
@@ -37,7 +41,7 @@ export function makeBillingCommand() {
                 console.log(JSON.stringify(data, null, 2));
             }
             else {
-                console.log(chalk.cyan(`Tier: ${data?.tier ?? "unknown"}`));
+                console.log(chalk.cyan(`Tier: ${data?.tier ?? NO_PLAN}`));
                 console.log();
                 if (data?.resources?.length) {
                     console.log(chalk.bold("Resources:"));

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

@@ -1,4 +1,5 @@
 import type { components } from "../generated/openapi.js";
+import { 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. */
@@ -39,6 +40,19 @@ export interface PendingConnection {
     /** The egress difference an allow is re-asked for; absent otherwise. */
     destinations?: 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[];
@@ -72,6 +86,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,6 +1,6 @@
 import chalk from "chalk";
 import { DEFAULT_CHAT_URL } from "./config.js";
-import { connectCallIds, connectionsPhrase, pendingConnectionsOf } from "./connect-pause.js";
+import { answerUrlFor, connectCallIds, connectionsPhrase, inputLabelsPhrase, pendingConnectionsOf, pendingInputsOf, } from "./connect-pause.js";
 import { CliUsageError } from "./errors.js";
 import { previewIsIncomplete, previewLines } from "./skills-apply-preview.js";
 export const CONVERSATION_MODES = ["plan", "ask", "auto"];
@@ -182,6 +182,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",
@@ -230,7 +231,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) {
@@ -254,9 +270,10 @@ export function buildRunEnvelope(result, agentRef, chatUrl = DEFAULT_CHAT_URL) {
             status = "incomplete";
             break;
         case "requires_action":
-            // A connect pause keeps exit 4 (§8, CLI agents D14): the CLI cannot answer it either.
+            // A connect pause keeps exit 4 (§8, CLI agents D14): the CLI cannot answer it either, 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;
@@ -266,7 +283,14 @@ 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
+        // command here can continue it, whatever else waits (#1320, P91).
+        const labels = inputLabelsPhrase(pendingInputs);
+        const needs = new Set(pendingInputs.map((i) => i.serverLabel)).size > 1 ? "need" : "needs";
+        next = `${labels} ${needs} your input: answer in chat at ${answerUrl}. The run continues there.`;
+    }
+    else if (status === "requires_approval" && ref && responseId) {
         next = `2kw agents decide ${shellQuote(ref)} --response ${responseId} --approve-all`;
     }
     else if (status === "requires_tool_output" && pendingToolCalls.length > 0) {
@@ -310,6 +334,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 }
@@ -317,6 +342,13 @@ export function buildRunEnvelope(result, agentRef, chatUrl = DEFAULT_CHAT_URL) {
         next,
     };
 }
+/** What the user does in chat for each input mode, in {@link printRunText}'s words. */
+const INPUT_MODE_WORDS = {
+    form: "form",
+    url: "link",
+    mixed: "form and link",
+    unknown: "question",
+};
 /** Human-readable rendering of an envelope on stdout. Every value printed is passed through {@link stripControl}. */
 export function printRunText(env) {
     const s = stripControl;
@@ -351,6 +383,21 @@ export function printRunText(env) {
         if (env.next)
             console.log(`\nDecide with:\n  ${s(env.next)}`);
     }
+    else if (env.status === "requires_tool_output" && env.pendingInputs.length) {
+        // A connector's question outranks every other pause (#1320, P91): it is answered in chat, and that
+        // one answer also carries the rest, so no command is printed for anything else.
+        console.log(chalk.yellow("\nPaused: the agent needs your answer in chat:"));
+        env.pendingInputs.forEach((i) => console.log(`  - ${s(i.serverLabel)}: ${s(i.tool)} (${INPUT_MODE_WORDS[i.mode]})`));
+        const others = [
+            env.pendingApprovals.length ? `${env.pendingApprovals.length} approval(s)` : null,
+            env.pendingConnections.length ? `${env.pendingConnections.length} connection(s)` : null,
+            env.pendingToolCalls.length ? `${env.pendingToolCalls.length} client-side tool call(s)` : null,
+        ].filter(Boolean);
+        if (others.length)
+            console.log(chalk.dim(`    It also waits for ${others.join(", ")}: answer them in chat too.`));
+        if (env.next)
+            console.log(`\n${s(env.next)}`);
+    }
     else if (env.status === "requires_tool_output") {
         if (env.pendingToolCalls.length) {
             console.log(chalk.yellow("\nPaused: the agent waits for client-side tool output:"));

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

@@ -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
@@ -144,4 +145,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2kw/ai",
-  "version": "7.0.0-dev.4",
+  "version": "7.0.0-dev.8",
   "description": "CLI for 2kw.ai — schema-driven document extraction, an OpenAI-compatible EU LLM gateway, transcription, prompts, datasets, and experiments from your terminal or agentic workflows. Ships as 2kw, backbone, and bb.",
   "keywords": [
     "cli",