@2kw/ai 8.0.3 → 8.1.0-dev.2

package/dist/commands/agent-run.js

@@ -9,6 +9,7 @@ import { buildRunEnvelope, EXIT_CODES, MODE_OPTION_HELP, modeItem, parseModeOpti
 import { continueWithDecisions, decisionsFromAnswers, fetchPendingApprovals, parseToolAnswers, planContinuation, } from "../lib/agent-decide.js";
 import { PromptAbortedError, promptApprovals, readlineAsk } from "../lib/approval-prompt.js";
 import { withModelOverride } from "../lib/agent-models.js";
+import { postResponse } from "../lib/response-stream.js";
 import { readStdinInput } from "./ai.js";
 export function resolveRunInput(arg, inputFile, readStdin = readStdinInput) {
     const text = readRunInput(arg, inputFile, readStdin);
@@ -146,7 +147,7 @@ export function makeAgentRunCommand() {
             const body = {
                 model: `agent/${agentRef}`,
                 input: mode ? [...turn, modeItem(mode)] : text ?? [],
-                stream: false,
+                stream: true,
             };
             if (opts.conversation)
                 body.conversation = opts.conversation;
@@ -154,9 +155,17 @@ export function makeAgentRunCommand() {
                 body.previous_response_id = opts.continue;
             let data;
             try {
-                // The generated body type does not model a bare-string input, hence the cast.
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                ({ data } = await withSpinner("Running agent...", () => client.POST("/v1/responses", { body })));
+                data = await withSpinner("Running agent...", (spinner) => postResponse(client, body, (started) => {
+                    // Printed at once (#1729), so a run cut off later can still be found.
+                    if (!started.conversation?.id)
+                        return;
+                    // ora's render() writes a frame even off a TTY, where it never spins.
+                    if (spinner.isSpinning)
+                        spinner.clear();
+                    console.error(`Conversation: ${started.conversation.id}`);
+                    if (spinner.isSpinning)
+                        spinner.render();
+                }));
             }
             catch (err) {
                 throw await withAgentSuggestions(client, agentRef, err);

package/dist/commands/ai.js

@@ -5,6 +5,7 @@ import { chatUrlFor, isJsonOutput, resolveConfig } from "../lib/config.js";
 import { CliUsageError } from "../lib/errors.js";
 import { withModelOverride } from "../lib/agent-models.js";
 import { formatList, withSpinner } from "../lib/output.js";
+import { postResponse } from "../lib/response-stream.js";
 import { buildRunEnvelope, extractResponseText, printRunText, } from "../lib/agent-run.js";
 import chalk from "chalk";
 export { extractResponseText };
@@ -125,7 +126,19 @@ export function makeAiCommand() {
             if (opts.conversation)
                 body.conversation = opts.conversation;
             const client = getClient(command);
-            const { data } = await withSpinner("Generating response...", () => client.POST("/v1/responses", { body }));
+            // An agent turn is streamed (#1732): a proxy cuts a request that answers nothing for 100 s.
+            const data = await withSpinner("Generating response...", async (spinner) => opts.agent
+                ? postResponse(client, body, (started) => {
+                    // Printed at once, as `agents run` does, so a turn cut off later can still be found.
+                    if (!started.conversation?.id)
+                        return;
+                    if (spinner.isSpinning)
+                        spinner.clear();
+                    console.error(`Conversation: ${started.conversation.id}`);
+                    if (spinner.isSpinning)
+                        spinner.render();
+                })
+                : (await client.POST("/v1/responses", { body })).data);
             printResponseResult(data, command, opts.agent);
         });
     });

package/dist/commands/responses.js

@@ -7,7 +7,8 @@ export function makeResponsesCommand() {
     cmd
         .command("get")
         .description("Read a background response as it stands now: queued, in_progress, requires_action, completed, " +
-        "incomplete, failed or cancelled. Only background responses can be read by id.")
+        "incomplete, failed or cancelled. Only background responses can be read by id: the result of " +
+        "`agents run` is read with `conversations items list <conversationId>`.")
         .argument("<responseId>", "Response ID")
         .action(async (responseId, _opts, command) => {
         await runAction(command, async () => {

package/dist/lib/agent-decide.js

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import { modeItem } from "./agent-run.js";
 import { CliUsageError } from "./errors.js";
 import { paginationParams } from "./pagination.js";
+import { postResponse } from "./response-stream.js";
 const defaultIo = {
     readFile: (path) => readFileSync(path, "utf-8"),
     // Not readStdinInput: that one trims, and a tool result is sent as read (P5).
@@ -215,12 +216,10 @@ export async function continueWithDecisions(client, agentId, responseId, decisio
     const body = {
         model: `agent/${agentId}${label ? `@${label}` : ""}${model ? `#${model}` : ""}`,
         previous_response_id: responseId,
-        stream: false,
+        stream: true,
         input: mode ? [...items, modeItem(mode)] : items,
     };
-    // The generated body type does not model backbone: extension items, hence the cast.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const { data } = await client.POST("/v1/responses", { body });
-    return data;
+    // Streamed for the reason a run is (#1729): the rest of the turn can outlast a proxy's timeout.
+    return postResponse(client, body);
 }
 //# sourceMappingURL=agent-decide.js.map

package/dist/lib/output.d.ts

@@ -1,3 +1,4 @@
+import { type Ora } from "ora";
 import type { Command } from "commander";
 type AnyRecord = Record<string, any>;
 /**
@@ -24,6 +25,6 @@ export declare function formatSuccess(message: string, command: Command): void;
 /**
  * Run an async action with a spinner.
  */
-export declare function withSpinner<T>(text: string, action: () => Promise<T>): Promise<T>;
+export declare function withSpinner<T>(text: string, action: (spinner: Ora) => Promise<T>): Promise<T>;
 export {};
 //# sourceMappingURL=output.d.ts.map

package/dist/lib/output.js

@@ -88,7 +88,7 @@ export function formatSuccess(message, command) {
 export async function withSpinner(text, action) {
     const spinner = ora(text).start();
     try {
-        const result = await action();
+        const result = await action(spinner);
         spinner.succeed();
         return result;
     }

package/dist/lib/response-stream.d.ts

@@ -0,0 +1,14 @@
+import type { ApiClient } from "./agent-lookup.js";
+import type { ResponsesResult } from "./agent-run.js";
+/**
+ * POSTs an agent turn to `/v1/responses` and returns its terminal response, as `stream: false` would (#1729).
+ * The turn is streamed: a proxy in front of the API cuts a request that answers nothing for 100 s (HTTP 524),
+ * and a stream's events and keepalives keep it open however long the run takes. A model that cannot stream
+ * is refused before any work (`stream_not_supported`), so that turn is sent again without a stream.
+ *
+ * `onStart` gets the response as `response.created` names it, before the run works. Once the conversation is
+ * known, a cut stream or Ctrl+C names it and the command that reads the run's result: a synchronous
+ * response cannot be read by id afterwards (`GET /v1/responses/{id}` reads background responses only).
+ */
+export declare function postResponse(client: ApiClient, body: Record<string, unknown>, onStart?: (started: ResponsesResult) => void): Promise<ResponsesResult>;
+//# sourceMappingURL=response-stream.d.ts.map

package/dist/lib/response-stream.js

@@ -0,0 +1,120 @@
+import { BackboneApiError } from "./errors.js";
+/**
+ * POSTs an agent turn to `/v1/responses` and returns its terminal response, as `stream: false` would (#1729).
+ * The turn is streamed: a proxy in front of the API cuts a request that answers nothing for 100 s (HTTP 524),
+ * and a stream's events and keepalives keep it open however long the run takes. A model that cannot stream
+ * is refused before any work (`stream_not_supported`), so that turn is sent again without a stream.
+ *
+ * `onStart` gets the response as `response.created` names it, before the run works. Once the conversation is
+ * known, a cut stream or Ctrl+C names it and the command that reads the run's result: a synchronous
+ * response cannot be read by id afterwards (`GET /v1/responses/{id}` reads background responses only).
+ */
+export async function postResponse(client, body, onStart) {
+    let response;
+    try {
+        // The generated body type does not model a bare-string input or backbone: items, hence the cast.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ({ response } = await client.POST("/v1/responses", { body: { ...body, stream: true }, parseAs: "stream" }));
+    }
+    catch (err) {
+        if (!(err instanceof BackboneApiError && err.code === "stream_not_supported"))
+            throw err;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const { data } = await client.POST("/v1/responses", { body: { ...body, stream: false } });
+        return data;
+    }
+    if (!response.body || !response.headers.get("content-type")?.includes("text/event-stream")) {
+        return (await response.json());
+    }
+    return readResponseStream(response.body, onStart);
+}
+/** How to read a run whose stream was lost: the conversation keeps every item the run wrote. */
+function readHint(started) {
+    const conversation = started?.conversation?.id;
+    return conversation
+        ? ` The run goes on on the server; read its result with: 2kw conversations items list ${conversation}`
+        : "";
+}
+/** Reads Open Responses server-sent events up to the terminal one; comments (keepalives) are skipped. */
+async function readResponseStream(body, onStart) {
+    let started;
+    let error;
+    const failed = () => new BackboneApiError({
+        status: 500,
+        error: error?.code ?? "run_failed",
+        code: error?.code ?? undefined,
+        message: error?.message ?? "The response failed.",
+        timestamp: new Date().toISOString(),
+    });
+    const onInterrupt = () => {
+        console.error(`Interrupted.${readHint(started)}`);
+        process.exit(130);
+    };
+    const handle = (frame) => {
+        const data = frame
+            .split(/\r?\n/)
+            .filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice(5).trimStart())
+            .join("\n");
+        if (!data || data === "[DONE]")
+            return undefined;
+        let event;
+        try {
+            event = JSON.parse(data);
+        }
+        catch {
+            return undefined; // a garbled frame is skipped: the run goes on, and its terminal event still ends it
+        }
+        switch (event.type) {
+            case "response.created":
+                started = event.response;
+                if (started?.conversation?.id)
+                    process.once("SIGINT", onInterrupt);
+                onStart?.(event.response);
+                return undefined;
+            case "error":
+                error = event;
+                return undefined;
+            case "response.completed":
+            case "response.incomplete":
+                return event.response;
+            case "response.failed":
+                throw failed();
+            default:
+                return undefined;
+        }
+    };
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const reader = body.getReader();
+    try {
+        for (;;) {
+            let chunk;
+            try {
+                chunk = await reader.read();
+            }
+            catch (err) {
+                throw new Error(`The connection closed before the run finished (${err.message}).${readHint(started)}`);
+            }
+            if (chunk.done)
+                break;
+            buffer += decoder.decode(chunk.value, { stream: true });
+            let end;
+            while ((end = /\r?\n\r?\n/.exec(buffer))) {
+                const frame = buffer.slice(0, end.index);
+                buffer = buffer.slice(end.index + end[0].length);
+                const terminal = handle(frame);
+                if (terminal)
+                    return terminal;
+            }
+        }
+    }
+    finally {
+        process.removeListener("SIGINT", onInterrupt);
+        await reader.cancel().catch(() => { });
+    }
+    if (error)
+        throw failed(); // an error event whose response.failed never arrived
+    throw new Error(`The response stream ended before the run finished.${readHint(started)}`);
+}
+//# sourceMappingURL=response-stream.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2kw/ai",
-  "version": "8.0.3",
+  "version": "8.1.0-dev.2",
   "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",