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

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

@@ -0,0 +1,41 @@
+import type { components } from "../generated/openapi.js";
+import type { ApiClient } from "./agent-lookup.js";
+import type { ResponsesResult } from "./agent-run.js";
+export type ApprovalRow = components["schemas"]["ToolApprovalDTO"];
+export interface DecideOptions {
+    approve?: string[];
+    reject?: string[];
+    approveAll?: boolean;
+    rejectAll?: boolean;
+    reason?: string;
+    remember?: boolean;
+}
+export interface Decision {
+    approvalId: string;
+    decision: "approve" | "reject";
+    hmac: string;
+    reason?: string;
+    remember?: "conversation";
+}
+export interface PromptAnswer {
+    decision: "approve" | "reject";
+    reason?: string;
+    remember?: boolean;
+}
+export declare function fetchPendingApprovals(client: ApiClient, agentId: string, responseId: string): Promise<ApprovalRow[]>;
+/**
+ * The backend refuses a continuation that leaves any pending approval of the paused
+ * response undecided (400 incomplete_tool_outputs), so the whole set is checked here first.
+ */
+export declare function planDecisions(pending: ApprovalRow[], opts: DecideOptions, responseId: string): Decision[];
+export declare function decisionsFromAnswers(pending: ApprovalRow[], answers: Map<string, PromptAnswer>): Decision[];
+/** Same item shape as n8n Decide Approval (#660). */
+export declare function toApprovalItems(decisions: Decision[]): Record<string, string>[];
+/**
+ * Continues on `agent/<agentId>[@<label>][#<model>]` with the label and model override the run used: the
+ * server resolves the continuation's tools, instructions and model from this reference, so both must match
+ * the run's or the continuation drops to another version or the agent's default model.
+ * Never the echoed `name@<versionNumber>` (it would 404 as a label).
+ */
+export declare function continueWithDecisions(client: ApiClient, agentId: string, responseId: string, decisions: Decision[], label?: string, model?: string): Promise<ResponsesResult>;
+//# sourceMappingURL=agent-decide.d.ts.map

package/dist/lib/agent-decide.js

@@ -0,0 +1,129 @@
+import { CliUsageError } from "./errors.js";
+import { paginationParams } from "./pagination.js";
+const MAX_PAGES = 50;
+export async function fetchPendingApprovals(client, agentId, responseId) {
+    const rows = [];
+    for (let page = 0; page < MAX_PAGES; page++) {
+        const { data } = await client.GET("/v1/agents/{agentId}/approvals", {
+            params: {
+                path: { agentId },
+                query: { status: "pending", ...paginationParams({ page: String(page), size: "100" }) },
+            },
+        });
+        const content = data?.content ?? [];
+        rows.push(...content.filter((r) => r.responseId === responseId));
+        if (data?.last !== false || content.length === 0)
+            break;
+    }
+    return rows;
+}
+function isDestructive(row) {
+    return (row.policyClass ?? "").toLowerCase() === "destructive";
+}
+function hmacOf(row) {
+    if (!row.hmac)
+        throw new CliUsageError(`Approval ${row.id} carries no hmac and cannot be decided from the CLI.`);
+    return row.hmac;
+}
+/**
+ * The backend refuses a continuation that leaves any pending approval of the paused
+ * response undecided (400 incomplete_tool_outputs), so the whole set is checked here first.
+ */
+export function planDecisions(pending, opts, responseId) {
+    if (pending.length === 0) {
+        throw new CliUsageError(`No pending approvals for ${responseId} (already decided or superseded).`);
+    }
+    const approve = opts.approve ?? [];
+    const reject = opts.reject ?? [];
+    const usesAll = !!opts.approveAll || !!opts.rejectAll;
+    if ((opts.approveAll && opts.rejectAll) || (usesAll && (approve.length > 0 || reject.length > 0))) {
+        throw new CliUsageError("Use either --approve-all / --reject-all or explicit --approve / --reject ids, not both.");
+    }
+    if (!usesAll && approve.length === 0 && reject.length === 0) {
+        throw new CliUsageError("Choose a decision: --approve <ids...>, --reject <ids...>, --approve-all or --reject-all.");
+    }
+    const choice = new Map();
+    if (usesAll) {
+        for (const r of pending)
+            choice.set(String(r.id), opts.approveAll ? "approve" : "reject");
+    }
+    else {
+        const seen = new Set();
+        const twice = new Set();
+        for (const [ids, d] of [[approve, "approve"], [reject, "reject"]]) {
+            for (const id of ids) {
+                if (seen.has(id))
+                    twice.add(id);
+                seen.add(id);
+                choice.set(id, d);
+            }
+        }
+        if (twice.size)
+            throw new CliUsageError(`Approvals decided more than once: ${[...twice].join(", ")}`);
+        const pendingIds = new Set(pending.map((r) => String(r.id)));
+        const foreign = [...seen].filter((id) => !pendingIds.has(id));
+        if (foreign.length)
+            throw new CliUsageError(`Not pending on ${responseId}: ${foreign.join(", ")}`);
+        const undecided = [...pendingIds].filter((id) => !seen.has(id));
+        if (undecided.length) {
+            throw new CliUsageError(`Every pending approval of a response must be decided in one call. Undecided: ${undecided.join(", ")}`);
+        }
+    }
+    if (opts.remember && pending.some((r) => choice.get(String(r.id)) === "approve" && isDestructive(r))) {
+        throw new CliUsageError("--remember cannot be used on a destructive tool call.");
+    }
+    return pending.map((r) => {
+        const decision = choice.get(String(r.id));
+        return {
+            approvalId: String(r.id),
+            decision,
+            hmac: hmacOf(r),
+            ...(opts.reason ? { reason: opts.reason } : {}),
+            ...(opts.remember && decision === "approve" ? { remember: "conversation" } : {}),
+        };
+    });
+}
+export function decisionsFromAnswers(pending, answers) {
+    return pending.map((r) => {
+        const answer = answers.get(String(r.id));
+        if (!answer)
+            throw new CliUsageError(`No answer for approval ${r.id}.`);
+        return {
+            approvalId: String(r.id),
+            decision: answer.decision,
+            hmac: hmacOf(r),
+            ...(answer.reason ? { reason: answer.reason } : {}),
+            ...(answer.remember && answer.decision === "approve" && !isDestructive(r) ? { remember: "conversation" } : {}),
+        };
+    });
+}
+/** Same item shape as n8n Decide Approval (#660). */
+export function toApprovalItems(decisions) {
+    return decisions.map((d) => ({
+        type: "backbone:approval_response",
+        approval_id: d.approvalId,
+        decision: d.decision,
+        hmac: d.hmac,
+        ...(d.reason ? { reason: d.reason } : {}),
+        ...(d.remember ? { remember: d.remember } : {}),
+    }));
+}
+/**
+ * Continues on `agent/<agentId>[@<label>][#<model>]` with the label and model override the run used: the
+ * server resolves the continuation's tools, instructions and model from this reference, so both must match
+ * the run's or the continuation drops to another version or the agent's default model.
+ * Never the echoed `name@<versionNumber>` (it would 404 as a label).
+ */
+export async function continueWithDecisions(client, agentId, responseId, decisions, label, model) {
+    const body = {
+        model: `agent/${agentId}${label ? `@${label}` : ""}${model ? `#${model}` : ""}`,
+        previous_response_id: responseId,
+        stream: false,
+        input: toApprovalItems(decisions),
+    };
+    // 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;
+}
+//# sourceMappingURL=agent-decide.js.map

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

@@ -0,0 +1,15 @@
+import type { components } from "../generated/openapi.js";
+import type { getClient } from "./client.js";
+export type ApiClient = ReturnType<typeof getClient>;
+export type AgentDTO = components["schemas"]["AgentDTO"];
+/** `name[@label][#model]`, split like the server: the model at the last `#`, then the label at the last `@`. */
+export declare function splitAgentRef(ref: string): {
+    name: string;
+    label: string | undefined;
+    model: string | undefined;
+};
+/** Exact, case-sensitive name match. The REST API only offers a substring `search`. */
+export declare function findAgentByName(client: ApiClient, name: string): Promise<AgentDTO | undefined>;
+export declare function suggestAgents(client: ApiClient, name: string, limit?: number): Promise<string[]>;
+export declare function resolveAgent(client: ApiClient, ref: string): Promise<AgentDTO>;
+//# sourceMappingURL=agent-lookup.d.ts.map

package/dist/lib/agent-lookup.js

@@ -0,0 +1,71 @@
+import { BackboneApiError, CliUsageError } from "./errors.js";
+import { paginationParams } from "./pagination.js";
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const PAGE_SIZE = 100;
+const MAX_PAGES = 50;
+/** `name[@label][#model]`, split like the server: the model at the last `#`, then the label at the last `@`. */
+export function splitAgentRef(ref) {
+    const hash = ref.lastIndexOf("#");
+    const model = hash >= 0 ? ref.slice(hash + 1) : undefined;
+    const base = hash >= 0 ? ref.slice(0, hash) : ref;
+    const at = base.lastIndexOf("@");
+    if (at <= 0)
+        return { name: base, label: undefined, model };
+    return { name: base.slice(0, at), label: base.slice(at + 1), model };
+}
+/** Exact, case-sensitive name match. The REST API only offers a substring `search`. */
+export async function findAgentByName(client, name) {
+    for (let page = 0; page < MAX_PAGES; page++) {
+        const { data } = await client.GET("/v1/agents", {
+            // A stable sort: the controller has none by default, and offset paging over
+            // an unordered result can skip rows between pages.
+            params: {
+                query: {
+                    search: name,
+                    ...paginationParams({ page: String(page), size: String(PAGE_SIZE), sort: ["id,asc"] }),
+                },
+            },
+        });
+        const content = data?.content ?? [];
+        const hit = content.find((a) => a.name === name);
+        if (hit)
+            return hit;
+        if (data?.last !== false || content.length === 0)
+            return undefined;
+    }
+    return undefined;
+}
+export async function suggestAgents(client, name, limit = 5) {
+    try {
+        const { data } = await client.GET("/v1/agents", {
+            params: { query: { search: name, ...paginationParams({ page: "0", size: String(limit) }) } },
+        });
+        return (data?.content ?? []).map((a) => a.name).slice(0, limit);
+    }
+    catch {
+        return [];
+    }
+}
+export async function resolveAgent(client, ref) {
+    if (UUID.test(ref)) {
+        try {
+            const { data } = await client.GET("/v1/agents/{id}", { params: { path: { id: ref } } });
+            if (data)
+                return data;
+        }
+        catch (err) {
+            // An unknown id is a usage error like an unknown name; anything else is a real failure.
+            if (!(err instanceof BackboneApiError && err.status === 404))
+                throw err;
+        }
+    }
+    else {
+        const found = await findAgentByName(client, ref);
+        if (found)
+            return found;
+    }
+    const suggestions = await suggestAgents(client, ref);
+    const hint = suggestions.length ? ` Did you mean: ${suggestions.join(", ")}` : "";
+    throw new CliUsageError(`Agent '${ref}' not found.${hint}`);
+}
+//# sourceMappingURL=agent-lookup.js.map

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

@@ -0,0 +1,28 @@
+/**
+ * The ordered model list of an agent or agent version (#591): the first entry is the default,
+ * the rest are the models a request may switch to with `agent/<ref>#<model>`. The backend owns
+ * the write rules (1-10 entries, unique, each configured for the org); the CLI only turns flags
+ * into the body fields. Refs: #626.
+ */
+export declare const MODEL_HELP = "Model (provider/model or a platform model); repeat for an ordered list, the first is the default";
+export declare const MODELS_HELP = "Ordered model list, comma-separated (e.g. openai/gpt-4o,gpt-4.1-mini); the first is the default";
+/** Commander collector for a repeatable `-m, --model <model>` flag. */
+export declare function collectModel(value: string, previous: string[] | undefined): string[];
+/**
+ * The `model` / `models` body fields from `--model` (repeatable) and `--models a,b`. One `--model`
+ * stays the scalar shorthand; a repeated `--model` or any `--models` sends the ordered list.
+ * Returns `{}` when neither flag was given; `required` turns that into a usage error.
+ */
+export declare function modelFieldsFromOptions(opts: {
+    model?: string[] | string;
+    models?: string;
+}, required: boolean): {
+    model?: string;
+    models?: string[];
+};
+/**
+ * An agent reference with a per-request model switch: `ref[@label]#<model>`. The model must be one
+ * of the resolved version's `models`; the server answers 400 otherwise.
+ */
+export declare function withModelOverride(agentRef: string, model: string | undefined): string;
+//# sourceMappingURL=agent-models.d.ts.map

package/dist/lib/agent-models.js

@@ -0,0 +1,53 @@
+import { CliUsageError } from "./errors.js";
+/**
+ * The ordered model list of an agent or agent version (#591): the first entry is the default,
+ * the rest are the models a request may switch to with `agent/<ref>#<model>`. The backend owns
+ * the write rules (1-10 entries, unique, each configured for the org); the CLI only turns flags
+ * into the body fields. Refs: #626.
+ */
+export const MODEL_HELP = "Model (provider/model or a platform model); repeat for an ordered list, the first is the default";
+export const MODELS_HELP = "Ordered model list, comma-separated (e.g. openai/gpt-4o,gpt-4.1-mini); the first is the default";
+/** Commander collector for a repeatable `-m, --model <model>` flag. */
+export function collectModel(value, previous) {
+    return [...(previous ?? []), value];
+}
+/**
+ * The `model` / `models` body fields from `--model` (repeatable) and `--models a,b`. One `--model`
+ * stays the scalar shorthand; a repeated `--model` or any `--models` sends the ordered list.
+ * Returns `{}` when neither flag was given; `required` turns that into a usage error.
+ */
+export function modelFieldsFromOptions(opts, required) {
+    const repeated = opts.model === undefined ? [] : Array.isArray(opts.model) ? opts.model : [opts.model];
+    if (opts.models !== undefined && repeated.length > 0) {
+        throw new CliUsageError("Use either --model (repeatable) or --models <a,b,...>, not both.");
+    }
+    if (opts.models !== undefined) {
+        const list = opts.models.split(",").map((m) => m.trim());
+        if (list.length === 0 || list.some((m) => m === "")) {
+            throw new CliUsageError(`--models needs a comma-separated list of model ids, got '${opts.models}'.`);
+        }
+        return { models: list };
+    }
+    if (repeated.length === 1)
+        return { model: repeated[0] };
+    if (repeated.length > 1)
+        return { models: repeated };
+    if (required)
+        throw new CliUsageError("A model is required: pass --model <model> (repeatable) or --models <a,b,...>.");
+    return {};
+}
+/**
+ * An agent reference with a per-request model switch: `ref[@label]#<model>`. The model must be one
+ * of the resolved version's `models`; the server answers 400 otherwise.
+ */
+export function withModelOverride(agentRef, model) {
+    if (model === undefined)
+        return agentRef;
+    if (model.trim() === "")
+        throw new CliUsageError("--model needs a model id.");
+    if (agentRef.includes("#")) {
+        throw new CliUsageError(`Give the model switch once: '${agentRef}' already names one after '#'; drop --model or the suffix.`);
+    }
+    return `${agentRef}#${model}`;
+}
+//# sourceMappingURL=agent-models.js.map

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

@@ -0,0 +1,83 @@
+type AnyRecord = Record<string, any>;
+export type RunStatus = "completed" | "requires_approval" | "requires_tool_output" | "incomplete";
+export interface PendingApproval {
+    approvalId: string;
+    callId: string;
+    tool: string;
+    arguments: unknown;
+    policyClass: string;
+    /** Why the automatic approver escalated this request to a human (#634); null when it did not. */
+    reason: string | null;
+}
+export interface ToolCallSummary {
+    tool: string;
+    callId: string;
+    /** `incomplete` when the server-side tool run failed (its `function_call_output` carries that status). */
+    status: "completed" | "incomplete";
+}
+export interface PendingToolCall {
+    tool: string;
+    callId: string;
+    arguments: unknown;
+}
+export interface RunEnvelope {
+    status: RunStatus;
+    /** Reserved for the server-side conversation mode (#656); always null until then. */
+    mode: null;
+    agent: string | null;
+    version: number | null;
+    responseId: string | null;
+    conversationId: string | null;
+    text: string;
+    toolCalls: ToolCallSummary[];
+    pendingApprovals: PendingApproval[];
+    pendingToolCalls: PendingToolCall[];
+    incompleteReason: string | null;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    } | null;
+    next: string | null;
+}
+/** Loose wire shape of a `POST /v1/responses` result; the OpenAPI spec types it as `object`. */
+export interface ResponsesResult {
+    id?: string;
+    status?: string;
+    model?: string;
+    output?: AnyRecord[];
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+        total_tokens?: number;
+    };
+    conversation?: {
+        id?: string;
+    } | null;
+    incomplete_details?: {
+        reason?: string;
+    } | null;
+}
+export declare const EXIT_CODES: Record<RunStatus, number>;
+/** The assistant's text: every `output_text` part of every `message` item, in order. */
+export declare function extractResponseText(result: ResponsesResult | undefined): string;
+/**
+ * The response echoes `model` as `agent/{name}@{versionNumber}` (all digits), optionally
+ * followed by a `#<model>` override. Only a trailing all-digit `@N` is read as a version;
+ * any other `@` suffix stays part of the name.
+ */
+export declare function parseAgentModel(model?: string): {
+    agent: string | null;
+    version: number | null;
+};
+/**
+ * Removes terminal control characters from model-, judge- or server-controlled text before it is
+ * printed, so an escape sequence in an answer cannot hide text, rewrite the screen or set the
+ * clipboard. Newlines and tabs stay. JSON output is never passed through this.
+ */
+export declare function stripControl(s: string): string;
+export declare function shellQuote(value: string): string;
+export declare function buildRunEnvelope(result: ResponsesResult | undefined, agentRef?: string): RunEnvelope;
+/** Human-readable rendering of an envelope on stdout. Every value printed is passed through {@link stripControl}. */
+export declare function printRunText(env: RunEnvelope): void;
+export {};
+//# sourceMappingURL=agent-run.d.ts.map

package/dist/lib/agent-run.js

@@ -0,0 +1,170 @@
+import chalk from "chalk";
+export const EXIT_CODES = {
+    completed: 0,
+    requires_approval: 3,
+    requires_tool_output: 4,
+    incomplete: 5,
+};
+/** The assistant's text: every `output_text` part of every `message` 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");
+}
+/**
+ * The response echoes `model` as `agent/{name}@{versionNumber}` (all digits), optionally
+ * followed by a `#<model>` override. Only a trailing all-digit `@N` is read as a version;
+ * any other `@` suffix stays part of the name.
+ */
+export function parseAgentModel(model) {
+    // Strip the `#<model>` override (from the last `#`, as the server splits it) before matching.
+    const hash = (model ?? "").lastIndexOf("#");
+    const ref = hash >= 0 ? (model ?? "").slice(0, hash) : model ?? "";
+    const withVersion = /^agent\/(.+)@(\d+)$/.exec(ref);
+    if (withVersion)
+        return { agent: withVersion[1], version: Number(withVersion[2]) };
+    const bare = /^agent\/(.+)$/.exec(ref);
+    if (bare)
+        return { agent: bare[1], version: null };
+    return { agent: null, version: null };
+}
+function parseArguments(raw) {
+    if (typeof raw !== "string")
+        return raw ?? {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+/** C0 controls except tab (\x09) and newline (\x0a), DEL, and C1 controls. */
+const CONTROL_CHARS = /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
+/**
+ * Removes terminal control characters from model-, judge- or server-controlled text before it is
+ * printed, so an escape sequence in an answer cannot hide text, rewrite the screen or set the
+ * clipboard. Newlines and tabs stay. JSON output is never passed through this.
+ */
+export function stripControl(s) {
+    return s.replace(CONTROL_CHARS, "");
+}
+export function shellQuote(value) {
+    if (/^[A-Za-z0-9._@/:-]+$/.test(value))
+        return value;
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+export function buildRunEnvelope(result, agentRef) {
+    const output = result?.output ?? [];
+    const { agent, version } = parseAgentModel(result?.model);
+    // call_id → status of its tool output; a failed server-side tool run is marked `incomplete`.
+    const outputStatuses = new Map(output
+        .filter((i) => i.type === "function_call_output")
+        .map((i) => [
+        String(i.call_id),
+        i.status === "incomplete" ? "incomplete" : "completed",
+    ]));
+    const pendingApprovals = output
+        // Only an open request is pending; judge- or grant-decided requests (#634, #629) carry another status.
+        .filter((i) => i.type === "backbone:approval_request" && (i.status === undefined || i.status === "in_progress"))
+        .map((i) => ({
+        approvalId: String(i.id),
+        callId: String(i.call_id),
+        tool: String(i.tool),
+        arguments: parseArguments(i.arguments),
+        policyClass: String(i.policy_class),
+        reason: typeof i.reason === "string" && i.reason ? i.reason : null,
+    }));
+    const withheldCallIds = new Set(pendingApprovals.map((a) => a.callId));
+    const toolCalls = [];
+    const pendingToolCalls = [];
+    for (const item of output) {
+        if (item.type !== "function_call")
+            continue;
+        const callId = String(item.call_id);
+        const outputStatus = outputStatuses.get(callId);
+        if (outputStatus) {
+            toolCalls.push({ tool: String(item.name), callId, status: outputStatus });
+        }
+        else if (!withheldCallIds.has(callId)) {
+            pendingToolCalls.push({ tool: String(item.name), callId, arguments: parseArguments(item.arguments) });
+        }
+    }
+    let status;
+    switch (result?.status) {
+        case "completed":
+            status = "completed";
+            break;
+        case "incomplete":
+            status = "incomplete";
+            break;
+        case "requires_action":
+            status = pendingToolCalls.length > 0 || pendingApprovals.length === 0 ? "requires_tool_output" : "requires_approval";
+            break;
+        default:
+            throw new Error(`Unexpected response status: ${result?.status}`);
+    }
+    const responseId = result?.id ?? null;
+    const ref = agentRef ?? agent;
+    const next = status === "requires_approval" && ref && responseId
+        ? `2kw agents decide ${shellQuote(ref)} --response ${responseId} --approve-all`
+        : null;
+    return {
+        status,
+        mode: null,
+        agent,
+        version,
+        responseId,
+        conversationId: result?.conversation?.id ?? null,
+        text: extractResponseText(result),
+        toolCalls,
+        pendingApprovals,
+        pendingToolCalls,
+        incompleteReason: result?.incomplete_details?.reason ?? null,
+        usage: result?.usage
+            ? { inputTokens: result.usage.input_tokens ?? 0, outputTokens: result.usage.output_tokens ?? 0 }
+            : null,
+        next,
+    };
+}
+/** Human-readable rendering of an envelope on stdout. Every value printed is passed through {@link stripControl}. */
+export function printRunText(env) {
+    const s = stripControl;
+    if (env.text)
+        console.log(s(env.text));
+    const head = [
+        env.agent ? `${env.agent}${env.version !== null ? `@${env.version}` : ""}` : null,
+        env.responseId,
+        env.conversationId,
+    ].filter(Boolean);
+    if (head.length)
+        console.log(chalk.dim(`\n── ${s(head.join(" · "))}`));
+    if (env.toolCalls.length)
+        console.log(chalk.dim(`   tools: ${env.toolCalls.map((c) => `${s(c.tool)} ${c.status === "incomplete" ? "✗" : "✓"}`).join("  ")}`));
+    if (env.status === "requires_approval") {
+        console.log(chalk.yellow("\nPaused for approval:"));
+        env.pendingApprovals.forEach((a, i) => {
+            console.log(`  ${i + 1}. ${s(a.tool)} [${s(a.policyClass)}] ${s(a.approvalId)}`);
+            // JSON.stringify escapes C0 controls but leaves DEL and C1 raw.
+            console.log(chalk.dim(`     ${s(JSON.stringify(a.arguments))}`));
+            if (a.reason)
+                console.log(chalk.dim(`     reason: ${s(a.reason)}`));
+        });
+        if (env.next)
+            console.log(`\nDecide with:\n  ${s(env.next)}`);
+    }
+    else if (env.status === "requires_tool_output") {
+        console.log(chalk.yellow("\nPaused: the agent needs client-side tool output this CLI cannot provide:"));
+        env.pendingToolCalls.forEach((c) => console.log(`  - ${s(c.tool)} (${s(c.callId)})`));
+    }
+    else if (env.status === "incomplete") {
+        console.log(chalk.yellow(`\nIncomplete: ${s(env.incompleteReason ?? "unknown reason")}`));
+    }
+}
+//# sourceMappingURL=agent-run.js.map

package/dist/lib/approval-prompt.d.ts

@@ -0,0 +1,18 @@
+import type { PromptAnswer } from "./agent-decide.js";
+import { type PendingApproval } from "./agent-run.js";
+export type Ask = (question: string) => Promise<string>;
+/** Raised when the prompt's input closes (EOF, Ctrl+C, Ctrl+D) before an answer arrives. */
+export declare class PromptAbortedError extends Error {
+    constructor();
+}
+/**
+ * Prompts go to stderr so stdout stays the agent's answer. A closed input never
+ * leaves a question hanging: every pending and later `ask` rejects with
+ * {@link PromptAbortedError}.
+ */
+export declare function readlineAsk(input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream): {
+    ask: Ask;
+    close: () => void;
+};
+export declare function promptApprovals(pending: PendingApproval[], ask: Ask, write?: (line: string) => void): Promise<Map<string, PromptAnswer>>;
+//# sourceMappingURL=approval-prompt.d.ts.map