@2kw/ai 6.2.0-dev.23 → 6.2.0-dev.26

package/dist/commands/agent-run.js

@@ -0,0 +1,190 @@
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
+import { BackboneApiError, CliUsageError } from "../lib/errors.js";
+import { withSpinner } from "../lib/output.js";
+import { resolveAgent, splitAgentRef, suggestAgents } from "../lib/agent-lookup.js";
+import { buildRunEnvelope, EXIT_CODES, printRunText, stripControl } from "../lib/agent-run.js";
+import { continueWithDecisions, decisionsFromAnswers, fetchPendingApprovals, planDecisions, } from "../lib/agent-decide.js";
+import { PromptAbortedError, promptApprovals, readlineAsk } from "../lib/approval-prompt.js";
+import { withModelOverride } from "../lib/agent-models.js";
+import { readStdinInput } from "./ai.js";
+export function resolveRunInput(arg, inputFile, readStdin = readStdinInput) {
+    if (arg)
+        return arg;
+    if (inputFile) {
+        let text;
+        try {
+            text = readFileSync(inputFile, "utf-8");
+        }
+        catch (err) {
+            const code = err.code;
+            throw new CliUsageError(`${inputFile}: cannot read file (${code ?? err.message})`);
+        }
+        // A byte order mark (U+FEFF) from Windows editors is not part of the task.
+        if (text.charCodeAt(0) === 0xfeff)
+            text = text.slice(1);
+        if (!text.trim())
+            throw new CliUsageError(`Input file ${inputFile} is empty.`);
+        return text;
+    }
+    const piped = readStdin();
+    if (piped)
+        return piped;
+    throw new CliUsageError("Input is required: pass it as an argument, with --input-file, or via stdin.");
+}
+async function withAgentSuggestions(client, agentRef, err) {
+    if (!(err instanceof BackboneApiError) || err.status !== 404 || !err.message.startsWith("Agent not found")) {
+        return err;
+    }
+    const names = await suggestAgents(client, splitAgentRef(agentRef).name);
+    if (names.length === 0)
+        return err;
+    return new BackboneApiError({
+        status: err.status,
+        error: err.errorType,
+        message: `${err.message}. Did you mean: ${names.join(", ")}`,
+        timestamp: err.timestamp,
+        code: err.code,
+    });
+}
+/**
+ * Prints a run result and sets the exit code. In interactive mode an approval pause
+ * is decided at the terminal and continued until the run stops pausing for approval.
+ * Continuations stay on the run's label and model override, and the envelope's `next` names both.
+ */
+async function finishRun(command, client, target, first, opts) {
+    const agentRef = `${target.name}${target.label ? `@${target.label}` : ""}${target.model ? `#${target.model}` : ""}`;
+    let result = first;
+    let env = buildRunEnvelope(result, agentRef);
+    if (opts.interactive && env.status === "requires_approval") {
+        try {
+            const agent = await resolveAgent(client, target.name);
+            while (env.status === "requires_approval" && env.responseId) {
+                const responseId = env.responseId;
+                // Show what the agent said this round before asking; only the final round's text reaches stdout.
+                if (env.text)
+                    console.error(stripControl(env.text));
+                let answers;
+                // One readline per round: the continuation spinner (ora) pauses stdin when it stops,
+                // and only a fresh readline resumes it for the next round's questions.
+                const { ask, close } = readlineAsk();
+                try {
+                    answers = await promptApprovals(env.pendingApprovals, ask);
+                }
+                catch (err) {
+                    // Ctrl+C / Ctrl+D / closed stdin: nothing was decided, so the run is still paused (exit 3 below).
+                    if (err instanceof PromptAbortedError) {
+                        console.error("Approval prompt closed; nothing was decided.");
+                        break;
+                    }
+                    throw err;
+                }
+                finally {
+                    close();
+                }
+                const rows = await fetchPendingApprovals(client, String(agent.id), responseId);
+                // Same local check as `decide`: never send a continuation with no decisions.
+                if (rows.length === 0) {
+                    throw new CliUsageError(`No pending approvals for ${responseId} (already decided or superseded).`);
+                }
+                const decisions = decisionsFromAnswers(rows, answers);
+                result = await withSpinner("Continuing...", () => continueWithDecisions(client, String(agent.id), responseId, decisions, target.label, target.model));
+                env = buildRunEnvelope(result, agentRef);
+            }
+        }
+        catch (err) {
+            // Whatever failed, the paused response id is what the user needs to resume by hand.
+            if (env.responseId) {
+                console.error(stripControl(`Run is still paused: response ${env.responseId}. Resume with: ${env.next}`));
+            }
+            throw err;
+        }
+    }
+    if (opts.raw) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else if (isJsonOutput(command)) {
+        console.log(JSON.stringify(env, null, 2));
+    }
+    else {
+        printRunText(env);
+    }
+    process.exitCode = EXIT_CODES[env.status];
+}
+export function makeAgentRunCommand() {
+    return new Command("run")
+        .description("Run an agent on a task (exit 3 = paused for approval, 4 = needs client tool output, 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)")
+        .option("--input-file <path>", "Read the task text from a file")
+        .option("--conversation <id>", "Continue a conversation")
+        .option("--continue <responseId>", "Continue from a previous response")
+        .option("--model <model>", "Run this request on another model from the agent's list (sends <agent>#<model>)")
+        .option("--no-input", "Never prompt for approvals, even on a terminal")
+        .option("--raw", "Print the untouched API response")
+        .action(async (agentArg, input, opts, command) => {
+        await runAction(command, async () => {
+            const agentRef = withModelOverride(agentArg, opts.model);
+            const text = resolveRunInput(input, opts.inputFile);
+            const client = getClient(command);
+            const body = { model: `agent/${agentRef}`, input: text, stream: false };
+            if (opts.conversation)
+                body.conversation = opts.conversation;
+            if (opts.continue)
+                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 })));
+            }
+            catch (err) {
+                throw await withAgentSuggestions(client, agentRef, err);
+            }
+            // The prompt reads stdin and writes to stderr, so those two decide; stdout may be redirected.
+            const interactive = !!process.stdin.isTTY && !!process.stderr.isTTY && !isJsonOutput(command) && opts.input !== false && !opts.raw;
+            const { name, label, model } = splitAgentRef(agentRef);
+            await finishRun(command, client, { name, label, model }, data, {
+                raw: !!opts.raw,
+                interactive,
+            });
+        });
+    });
+}
+export function makeAgentDecideCommand() {
+    return new Command("decide")
+        .description("Decide every pending approval of a paused run and continue it")
+        .argument("<agent>", "Agent name or id, optionally with @label and #model (use the same @label and #model the run used)")
+        .requiredOption("--response <responseId>", "The paused response id (responseId in the run envelope)")
+        .option("--approve <ids...>", "Approval ids to approve")
+        .option("--reject <ids...>", "Approval ids to reject")
+        .option("--approve-all", "Approve every pending approval of the response")
+        .option("--reject-all", "Reject every pending approval of the response")
+        .option("--reason <text>", "Reason recorded on each decision (the model sees it on rejects)")
+        .option("--remember", "Also approve later calls of the same tool in this conversation")
+        .option("--raw", "Print the untouched API response")
+        .action(async (agentRef, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { name, label, model } = splitAgentRef(agentRef);
+            // Dropped silently, an empty override would continue the run on the default model.
+            if (model === "")
+                throw new CliUsageError(`Empty #model in '${agentRef}': use the model the run used, or drop the '#'.`);
+            const agent = await resolveAgent(client, name);
+            const pending = await fetchPendingApprovals(client, String(agent.id), opts.response);
+            const decisions = planDecisions(pending, {
+                approve: opts.approve,
+                reject: opts.reject,
+                approveAll: opts.approveAll,
+                rejectAll: opts.rejectAll,
+                reason: opts.reason,
+                remember: opts.remember,
+            }, opts.response);
+            const result = await withSpinner("Continuing...", () => continueWithDecisions(client, String(agent.id), opts.response, decisions, label, model));
+            await finishRun(command, client, { name, label, model }, result, { raw: !!opts.raw, interactive: false });
+        });
+    });
+}
+//# sourceMappingURL=agent-run.js.map

package/dist/commands/agent-versions.js

@@ -2,6 +2,8 @@ import { Command } from "commander";
 import { getClient, runAction } from "../lib/client.js";
 import { formatPage, formatDetail, formatSuccess } from "../lib/output.js";
 import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+import { maskSecrets } from "../agent-config/file.js";
+import { collectModel, MODEL_HELP, MODELS_HELP, modelFieldsFromOptions } from "../lib/agent-models.js";
 export function makeAgentVersionsCommand() {
     const cmd = new Command("versions").description("Manage agent versions");
     const list = new Command("list").description("List versions of an agent");
@@ -16,7 +18,8 @@ export function makeAgentVersionsCommand() {
                     query: paginationParams(opts),
                 },
             });
-            formatPage(data, command, ["id", "versionNumber", "model", "changeDescription", "createdAt"]);
+            // Version reads return webhook secrets in plaintext (#669); only `agents export --include-secrets` prints them.
+            formatPage(maskSecrets(data, []), command, ["id", "versionNumber", "models", "changeDescription", "createdAt"]);
         });
     });
     cmd.addCommand(list);
@@ -29,7 +32,7 @@ export function makeAgentVersionsCommand() {
         await runAction(command, async () => {
             const client = getClient(command);
             const { data } = await client.GET("/v1/agents/{agentId}/versions/{versionId}", { params: { path: { agentId: opts.agent, versionId } } });
-            formatDetail(data, command);
+            formatDetail(maskSecrets(data, []), command);
         });
     });
     cmd
@@ -40,14 +43,15 @@ export function makeAgentVersionsCommand() {
         await runAction(command, async () => {
             const client = getClient(command);
             const { data } = await client.GET("/v1/agents/{agentId}/versions/latest", { params: { path: { agentId: opts.agent } } });
-            formatDetail(data, command);
+            formatDetail(maskSecrets(data, []), command);
         });
     });
     cmd
         .command("create")
         .description("Create a new agent version")
         .requiredOption("--agent <id>", "Agent ID")
-        .requiredOption("-m, --model <model>", "Model (provider/model)")
+        .option("-m, --model <model>", MODEL_HELP, collectModel)
+        .option("--models <list>", MODELS_HELP)
         .option("-i, --instructions <text>", "System instructions")
         .option("--options <json>", "Model options as JSON")
         .option("--tools <json>", "Tool definitions as JSON")
@@ -56,11 +60,12 @@ export function makeAgentVersionsCommand() {
         .option("-c, --change-description <text>", "Change description")
         .action(async (opts, command) => {
         await runAction(command, async () => {
+            const models = modelFieldsFromOptions(opts, true);
             const client = getClient(command);
             const { data } = await client.POST("/v1/agents/{agentId}/versions", {
                 params: { path: { agentId: opts.agent } },
                 body: {
-                    model: opts.model,
+                    ...models,
                     instructions: opts.instructions,
                     changeDescription: opts.changeDescription,
                     options: opts.options ? JSON.parse(opts.options) : undefined,
@@ -69,7 +74,7 @@ export function makeAgentVersionsCommand() {
                     hitlPolicy: opts.hitlPolicy ? JSON.parse(opts.hitlPolicy) : undefined,
                 },
             });
-            formatDetail(data, command);
+            formatDetail(maskSecrets(data, []), command);
         });
     });
     cmd
@@ -81,7 +86,7 @@ export function makeAgentVersionsCommand() {
         await runAction(command, async () => {
             const client = getClient(command);
             const { data } = await client.PUT("/v1/agents/{agentId}/versions/{versionId}/activate", { params: { path: { agentId: opts.agent, versionId } } });
-            formatDetail(data, command);
+            formatDetail(maskSecrets(data, []), command);
         });
     });
     cmd

package/dist/commands/agents.js

@@ -4,6 +4,12 @@ import { formatPage, formatDetail, formatSuccess } from "../lib/output.js";
 import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
 import { makeAgentVersionsCommand } from "./agent-versions.js";
 import { makeAgentLabelsCommand } from "./agent-labels.js";
+import { makeAgentDecideCommand, makeAgentRunCommand } from "./agent-run.js";
+import { makeAgentApplyCommand } from "./agent-apply.js";
+import { makeAgentExportCommand } from "./agent-export.js";
+import { makeAgentInitCommand, makeAgentSchemaCommand } from "./agent-init.js";
+import { maskSecrets } from "../agent-config/file.js";
+import { collectModel, MODEL_HELP, MODELS_HELP, modelFieldsFromOptions } from "../lib/agent-models.js";
 export function makeAgentsCommand() {
     const cmd = new Command("agents").description("Manage agents");
     const list = new Command("list").description("List agents");
@@ -15,7 +21,8 @@ export function makeAgentsCommand() {
             const { data } = await client.GET("/v1/agents", {
                 params: { query: { search: opts.search, ...paginationParams(opts) } },
             });
-            formatPage(data, command, ["id", "name", "model", "latestVersionId", "createdAt"]);
+            // Agent reads return webhook secrets in plaintext (#669); only `export --include-secrets` prints them.
+            formatPage(maskSecrets(data, []), command, ["id", "name", "models", "latestVersionId", "createdAt"]);
         });
     });
     cmd.addCommand(list);
@@ -29,14 +36,15 @@ export function makeAgentsCommand() {
             const { data } = await client.GET("/v1/agents/{id}", {
                 params: { path: { id } },
             });
-            formatDetail(data, command);
+            formatDetail(maskSecrets(data, []), command);
         });
     });
     cmd
         .command("create")
         .description("Create a new agent")
         .requiredOption("-n, --name <name>", "Agent name")
-        .requiredOption("-m, --model <model>", "Model (provider/model)")
+        .option("-m, --model <model>", MODEL_HELP, collectModel)
+        .option("--models <list>", MODELS_HELP)
         .option("-d, --description <text>", "Agent description")
         .option("-i, --instructions <text>", "System instructions")
         .option("--options <json>", "Model options as JSON")
@@ -45,11 +53,12 @@ export function makeAgentsCommand() {
         .option("--hitl-policy <json>", "Human-in-the-loop policy as JSON")
         .action(async (opts, command) => {
         await runAction(command, async () => {
+            const models = modelFieldsFromOptions(opts, true);
             const client = getClient(command);
             const { data } = await client.POST("/v1/agents", {
                 body: {
                     name: opts.name,
-                    model: opts.model,
+                    ...models,
                     description: opts.description,
                     instructions: opts.instructions,
                     options: opts.options ? JSON.parse(opts.options) : undefined,
@@ -58,7 +67,7 @@ export function makeAgentsCommand() {
                     hitlPolicy: opts.hitlPolicy ? JSON.parse(opts.hitlPolicy) : undefined,
                 },
             });
-            formatDetail(data, command);
+            formatDetail(maskSecrets(data, []), command);
         });
     });
     cmd
@@ -66,7 +75,8 @@ export function makeAgentsCommand() {
         .description("Update an agent's metadata and configuration")
         .argument("<id>", "Agent ID")
         .option("-n, --name <name>", "New name")
-        .option("-m, --model <model>", "New model (provider/model)")
+        .option("-m, --model <model>", `${MODEL_HELP}; replaces the stored list`, collectModel)
+        .option("--models <list>", `${MODELS_HELP}; replaces the stored list`)
         .option("-d, --description <text>", "New description")
         .option("-i, --instructions <text>", "New system instructions")
         .option("--options <json>", "New model options as JSON")
@@ -79,8 +89,7 @@ export function makeAgentsCommand() {
             const body = {};
             if (opts.name)
                 body.name = opts.name;
-            if (opts.model)
-                body.model = opts.model;
+            Object.assign(body, modelFieldsFromOptions(opts, false));
             if (opts.description !== undefined)
                 body.description = opts.description;
             if (opts.instructions !== undefined)
@@ -97,7 +106,7 @@ export function makeAgentsCommand() {
                 params: { path: { id } },
                 body: body,
             });
-            formatDetail(data, command);
+            formatDetail(maskSecrets(data, []), command);
         });
     });
     cmd
@@ -147,6 +156,12 @@ export function makeAgentsCommand() {
         });
     });
     cmd.addCommand(toolCatalogs);
+    cmd.addCommand(makeAgentRunCommand());
+    cmd.addCommand(makeAgentDecideCommand());
+    cmd.addCommand(makeAgentApplyCommand());
+    cmd.addCommand(makeAgentExportCommand());
+    cmd.addCommand(makeAgentInitCommand());
+    cmd.addCommand(makeAgentSchemaCommand());
     cmd.addCommand(makeAgentVersionsCommand());
     cmd.addCommand(makeAgentLabelsCommand());
     return cmd;

package/dist/commands/ai.d.ts

@@ -1,4 +1,6 @@
 import { Command } from "commander";
+import { extractResponseText } from "../lib/agent-run.js";
+export { extractResponseText };
 /**
  * Reads a single text input from stdin, or `undefined` when stdin is a TTY
  * (nothing was piped in) or empty. Mirrors the `-` stdin convention used by
@@ -11,47 +13,13 @@ export declare function readStdinInput(): string | undefined;
  * `--agent` / `--model` options, per {@code ModelReferenceResolver}'s
  * grammar: a stored agent is addressed as `agent/{ref}` (an `--agent`
  * value of `ref@label` naturally composes into `agent/ref@label`), a
- * direct gateway call is a plain `provider/model` string.
+ * direct gateway call is a plain `provider/model` string. With both, `--model`
+ * switches the agent to another entry of its `models` list for this request:
+ * `agent/{ref}#{model}` (#591, #626).
  */
 export declare function resolveModel(opts: {
     agent?: string;
     model?: string;
 }): string;
-interface ResponseContentPart {
-    type?: string;
-    text?: string;
-}
-interface ResponseOutputItem {
-    type?: string;
-    role?: string;
-    content?: ResponseContentPart[];
-}
-interface ResponseUsage {
-    input_tokens?: number;
-    output_tokens?: number;
-    total_tokens?: number;
-}
-interface ResponseResult {
-    id?: string;
-    status?: string;
-    model?: string;
-    output?: ResponseOutputItem[];
-    usage?: ResponseUsage;
-    conversation?: {
-        id?: string;
-    };
-}
-/**
- * Extracts the assistant's text from a Responses API result: the
- * `output_text` content parts of every `message` output item, in order.
- */
-export declare function extractResponseText(result: ResponseResult | undefined): string;
-/**
- * Extracts the text delta from one line of an SSE stream, or `undefined`
- * when the line carries nothing to print (not a `data:` line, `[DONE]`, an
- * event with no textual delta, or unparsable JSON).
- */
-export declare function extractSseDelta(line: string): string | undefined;
 export declare function makeAiCommand(): Command;
-export {};
 //# sourceMappingURL=ai.d.ts.map

package/dist/commands/ai.js

@@ -1,10 +1,13 @@
 import { Command } from "commander";
 import { readFileSync } from "node:fs";
-import { getClient, resolveAuthHeader, runAction } from "../lib/client.js";
-import { resolveConfig, isJsonOutput } from "../lib/config.js";
-import { BackboneApiError } from "../lib/errors.js";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } 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 { buildRunEnvelope, extractResponseText, printRunText, } from "../lib/agent-run.js";
 import chalk from "chalk";
+export { extractResponseText };
 /**
  * Reads a single text input from stdin, or `undefined` when stdin is a TTY
  * (nothing was piped in) or empty. Mirrors the `-` stdin convention used by
@@ -27,134 +30,26 @@ export function readStdinInput() {
  * `--agent` / `--model` options, per {@code ModelReferenceResolver}'s
  * grammar: a stored agent is addressed as `agent/{ref}` (an `--agent`
  * value of `ref@label` naturally composes into `agent/ref@label`), a
- * direct gateway call is a plain `provider/model` string.
+ * direct gateway call is a plain `provider/model` string. With both, `--model`
+ * switches the agent to another entry of its `models` list for this request:
+ * `agent/{ref}#{model}` (#591, #626).
  */
 export function resolveModel(opts) {
-    if (opts.agent && opts.model) {
-        throw new Error("Use either --agent or --model, not both.");
-    }
     if (opts.agent)
-        return `agent/${opts.agent}`;
+        return `agent/${withModelOverride(opts.agent, opts.model)}`;
     if (opts.model)
         return opts.model;
     throw new Error("Either --agent or --model is required.");
 }
-/**
- * Extracts the assistant's text from a Responses API result: the
- * `output_text` content parts of every `message` output item, in order.
- */
-export function extractResponseText(result) {
-    const parts = [];
-    for (const item of result?.output ?? []) {
-        if (item.type !== "message")
-            continue;
-        for (const part of item.content ?? []) {
-            if (part.type === "output_text" && part.text) {
-                parts.push(part.text);
-            }
-        }
-    }
-    return parts.join("\n");
-}
-function printResponseResult(result, command) {
+function printResponseResult(result, command, agentRef) {
     if (isJsonOutput(command)) {
         console.log(JSON.stringify(result, null, 2));
         return;
     }
-    const text = extractResponseText(result);
-    if (text) {
-        console.log(text);
-    }
-    if (result?.status && result.status !== "completed") {
-        console.log(chalk.yellow(`\n[status: ${result.status}]`));
-    }
+    printRunText(buildRunEnvelope(result, agentRef));
     if (result?.usage) {
         const usage = result.usage;
-        console.log(chalk.dim(`\n[${result.model} | ${usage.input_tokens} in / ${usage.output_tokens} out / ${usage.total_tokens} total tokens]`));
-    }
-    if (result?.conversation?.id) {
-        console.log(chalk.dim(`[conversation: ${result.conversation.id}]`));
-    }
-}
-/**
- * Extracts the text delta from one line of an SSE stream, or `undefined`
- * when the line carries nothing to print (not a `data:` line, `[DONE]`, an
- * event with no textual delta, or unparsable JSON).
- */
-export function extractSseDelta(line) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("data:"))
-        return undefined;
-    const payload = trimmed.slice(5).trim();
-    if (!payload || payload === "[DONE]")
-        return undefined;
-    try {
-        const event = JSON.parse(payload);
-        const delta = event.delta;
-        return typeof delta === "string" ? delta : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function parseErrorResponse(res) {
-    let body = {};
-    try {
-        body = await res.json();
-    }
-    catch {
-        // Fall through to the defaults below.
-    }
-    return new BackboneApiError({
-        status: body.status ?? res.status,
-        error: body.error ?? res.statusText,
-        message: body.message ?? `HTTP ${res.status}: ${res.statusText}`,
-        timestamp: body.timestamp ?? new Date().toISOString(),
-    });
-}
-/**
- * Streams `POST /v1/responses` over SSE, printing text deltas as they
- * arrive. Bypasses the typed openapi-fetch client (like the multipart raw
- * `fetch` calls in convert.ts/transcribe.ts) because the response body must
- * be read incrementally rather than parsed whole.
- */
-async function streamResponse(command, body) {
-    const config = resolveConfig(command);
-    const authHeader = await resolveAuthHeader(config);
-    const baseUrl = config.baseUrl.replace(/\/+$/, "");
-    const res = await withSpinner("Connecting...", () => fetch(`${baseUrl}/v1/responses`, {
-        method: "POST",
-        headers: {
-            Authorization: authHeader,
-            "Content-Type": "application/json",
-            Accept: "text/event-stream",
-        },
-        body: JSON.stringify(body),
-    }));
-    if (!res.ok || !res.body) {
-        throw await parseErrorResponse(res);
-    }
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let wroteAny = false;
-    for (;;) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-            const delta = extractSseDelta(line);
-            if (delta) {
-                process.stdout.write(delta);
-                wroteAny = true;
-            }
-        }
-    }
-    if (wroteAny) {
-        process.stdout.write("\n");
+        console.log(chalk.dim(`[${result.model} | ${usage.input_tokens} in / ${usage.output_tokens} out / ${usage.total_tokens} total tokens]`));
     }
 }
 export function makeAiCommand() {
@@ -208,12 +103,15 @@ export function makeAiCommand() {
         .command("respond")
         .description("Send a request to the OpenAI-compatible Responses endpoint")
         .argument("[input]", "Input text (reads stdin if omitted)")
-        .option("--agent <id>", "Invoke a stored agent by id or name (mutually exclusive with --model)")
-        .option("--model <id>", "Model in provider/model format (mutually exclusive with --agent)")
+        .option("--agent <id>", "Invoke a stored agent by id or name, optionally with @label")
+        .option("--model <id>", "Model in provider/model format; with --agent, one of the agent's models to run this request on")
         .option("--conversation <id>", "Conversation ID this response belongs to")
-        .option("--stream", "Stream the response as it is generated")
+        .option("--stream", "Stream the response (not supported by the server yet, #148)")
         .action(async (input, opts, command) => {
         await runAction(command, async () => {
+            if (opts.stream) {
+                throw new CliUsageError("Streaming is not supported by the server yet (#148). Run without --stream.");
+            }
             const model = resolveModel(opts);
             const inputText = input ?? readStdinInput();
             if (!inputText) {
@@ -222,24 +120,19 @@ export function makeAiCommand() {
             const body = {
                 model,
                 input: inputText,
-                stream: !!opts.stream,
+                stream: false,
             };
             if (opts.conversation)
                 body.conversation = opts.conversation;
-            if (opts.stream) {
-                await streamResponse(command, body);
-            }
-            else {
-                const client = getClient(command);
-                const { data } = await withSpinner("Generating response...", () => 
-                // The wire `input` field also accepts a bare string (shorthand for
-                // a single user message; see ResponseItemInputDeserializer), which
-                // the generated type does not model — hence the cast, same as the
-                // untyped convert.ts source-conversion calls.
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                client.POST("/v1/responses", { body }));
-                printResponseResult(data, command);
-            }
+            const client = getClient(command);
+            const { data } = await withSpinner("Generating response...", () => 
+            // The wire `input` field also accepts a bare string (shorthand for
+            // a single user message; see ResponseItemInputDeserializer), which
+            // the generated type does not model — hence the cast, same as the
+            // untyped convert.ts source-conversion calls.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            client.POST("/v1/responses", { body }));
+            printResponseResult(data, command, opts.agent);
         });
     });
     cmd