@agent-api/cli 0.2.0 → 0.3.0

package/dist/workbench/settings-controller.js

@@ -1,288 +0,0 @@
-import { clearPresetToolCatalogCache, isAvailablePreset, listAvailablePresets, } from "../agent.js";
-import { loadWorkbenchPreferences, updateWorkbenchPreferences, } from "../config.js";
-import { ensureConfiguredIsolator, installConfiguredIsolator, normalizeSourceURL, relocateInstalledIsolator, validateInstalledIsolator, } from "./isolator-installer.js";
-export function createWorkbenchSettingsController(options = {}) {
-    const loadWorkbenchPreferencesImpl = options.loadWorkbenchPreferencesImpl ?? loadWorkbenchPreferences;
-    const updateWorkbenchPreferencesImpl = options.updateWorkbenchPreferencesImpl ?? updateWorkbenchPreferences;
-    const isAvailablePresetImpl = options.isAvailablePresetImpl ?? isAvailablePreset;
-    const listAvailablePresetsImpl = options.listAvailablePresetsImpl ?? listAvailablePresets;
-    const clearPresetToolCatalogCacheImpl = options.clearPresetToolCatalogCacheImpl ?? clearPresetToolCatalogCache;
-    const isolatorInstallOptions = options.isolatorInstallOptions ?? {};
-    const formatError = options.formatError ?? userFacingError;
-    return {
-        async loadInitial(agentOptions) {
-            const loadedPreferences = await loadWorkbenchPreferencesImpl();
-            const { preferences, activity, warning } = await reconcileConfiguredIsolator(loadedPreferences, updateWorkbenchPreferencesImpl, isolatorInstallOptions, formatError);
-            return {
-                defaultPreset: preferences.defaultPreset,
-                ...(preferences.isolation ? { shellIsolation: preferences.isolation } : {}),
-                ...(activity ? { activity } : {}),
-                ...(warning ? { warning } : {}),
-                runPreset: shouldApplyDefaultPreset(agentOptions)
-                    ? effectiveDefaultPreset(preferences, agentOptions.preset)
-                    : undefined,
-            };
-        },
-        async saveShellIsolationMode(value) {
-            const mode = normalizeShellIsolationMode(value);
-            const preferences = await updateWorkbenchPreferencesImpl({ isolation: { mode } });
-            return {
-                ...settingsSnapshot(preferences),
-                message: `Saved shell isolation mode: ${formatShellIsolation(preferences.isolation)}.`,
-                activity: `Shell isolation mode saved: ${preferences.isolation?.mode ?? "auto"}`,
-            };
-        },
-        async saveIsolatorPath(value) {
-            const executablePath = normalizeIsolatorPath(value);
-            if (!executablePath) {
-                const preferences = await updateWorkbenchPreferencesImpl({ isolation: { executablePath } });
-                return {
-                    ...settingsSnapshot(preferences),
-                    message: `Saved isolator path: ${formatIsolatorPath(preferences.isolation)}.`,
-                    activity: "Isolator path cleared",
-                };
-            }
-            const current = (await loadWorkbenchPreferencesImpl()).isolation;
-            if (current?.sourceURL) {
-                const result = await installConfiguredIsolator({
-                    sourceURL: current.sourceURL,
-                    executablePath,
-                    sha256: current.sha256,
-                }, isolatorInstallOptions);
-                const preferences = await updateWorkbenchPreferencesImpl({
-                    isolation: { executablePath: result.executablePath, sourceURL: result.sourceURL, sha256: result.sha256, installSkipped: false },
-                });
-                return {
-                    ...settingsSnapshot(preferences),
-                    message: `Installed isolator to ${result.executablePath}.`,
-                    activity: result.replaced ? "Isolator refreshed" : "Isolator installed",
-                };
-            }
-            const validatedPath = current?.executablePath
-                ? await relocateInstalledIsolator(current.executablePath, executablePath, isolatorInstallOptions)
-                : await validateInstalledIsolator(executablePath, isolatorInstallOptions);
-            const preferences = await updateWorkbenchPreferencesImpl({ isolation: { executablePath: validatedPath, installSkipped: false } });
-            return {
-                ...settingsSnapshot(preferences),
-                message: `Saved verified isolator path: ${formatIsolatorPath(preferences.isolation)}.`,
-                activity: "Isolator path verified",
-            };
-        },
-        async saveIsolatorSource(value) {
-            const sourceURL = normalizeIsolatorSource(value);
-            const current = (await loadWorkbenchPreferencesImpl()).isolation;
-            if (!sourceURL) {
-                const preferences = await updateWorkbenchPreferencesImpl({ isolation: { sourceURL, sha256: null } });
-                return {
-                    ...settingsSnapshot(preferences),
-                    message: "Cleared isolator source URL.",
-                    activity: "Isolator source cleared",
-                };
-            }
-            if (!current?.executablePath) {
-                throw new Error("Set a verified isolator path before saving a source URL.");
-            }
-            const result = await installConfiguredIsolator({
-                sourceURL,
-                executablePath: current.executablePath,
-                sha256: current.sha256,
-            }, isolatorInstallOptions);
-            const preferences = await updateWorkbenchPreferencesImpl({
-                isolation: { sourceURL: result.sourceURL, executablePath: result.executablePath, sha256: result.sha256, installSkipped: false },
-            });
-            return {
-                ...settingsSnapshot(preferences),
-                message: `Installed isolator from ${result.sourceURL}.`,
-                activity: result.replaced ? "Isolator refreshed from source" : "Isolator installed from source",
-            };
-        },
-        async saveDefaultPreset(input) {
-            const normalized = normalizeDefaultPreset(input.value);
-            if (typeof normalized === "string" && !(await isAvailablePresetImpl(input.profileName, normalized))) {
-                throw new UnknownPresetError(normalized);
-            }
-            const preferences = await updateWorkbenchPreferencesImpl({ defaultPreset: normalized });
-            return {
-                defaultPreset: preferences.defaultPreset,
-                ...(preferences.isolation ? { shellIsolation: preferences.isolation } : {}),
-                runPreset: shouldApplyDefaultPreset(input.options)
-                    ? effectiveDefaultPreset(preferences, input.options.preset)
-                    : undefined,
-                message: `Saved default preset: ${formatDefaultPreset(preferences.defaultPreset)}.`,
-                activity: `Default preset saved: ${formatDefaultPreset(preferences.defaultPreset)}`,
-            };
-        },
-        async validatePreset(profileName, preset) {
-            return isAvailablePresetImpl(profileName, preset);
-        },
-        async presetListText(input) {
-            try {
-                const presets = await listAvailablePresetsImpl(input.profileName);
-                return [
-                    input.prefix,
-                    "",
-                    "Available presets:",
-                    ...formatPresetList(presets, input.currentPreset),
-                ].join("\n");
-            }
-            catch (error) {
-                return [
-                    input.prefix,
-                    "",
-                    `Available presets could not be loaded: ${formatError(error)}`,
-                ].join("\n");
-            }
-        },
-        configText: runConfigText,
-        defaultPresetHelp(defaultPreset) {
-            return `Default preset: ${formatDefaultPreset(defaultPreset)}. Use /config preset <name>, /config preset none, or /config preset reset.`;
-        },
-        shellIsolationHelp(shellIsolation) {
-            return `Shell isolation: ${formatShellIsolation(shellIsolation)}. Use /config isolation none, /config isolation auto, or /config isolation required.`;
-        },
-        isolatorPathHelp(shellIsolation) {
-            return [
-                `Isolator path: ${formatIsolatorPath(shellIsolation)}`,
-                `Isolator source: ${formatIsolatorSource(shellIsolation)}`,
-                "Use /config isolator path <absolute-path>, /config isolator source <https-url>, or /config isolator none to clear the path.",
-            ].join("\n");
-        },
-        clearPresetToolCatalogCache(baseURL) {
-            clearPresetToolCatalogCacheImpl(baseURL);
-        },
-    };
-}
-export class UnknownPresetError extends Error {
-    preset;
-    constructor(preset) {
-        super(`Unknown preset: ${preset}`);
-        this.preset = preset;
-        this.name = "UnknownPresetError";
-    }
-}
-export function normalizeDefaultPreset(value) {
-    const trimmed = value.trim();
-    const lowered = trimmed.toLowerCase();
-    if (!trimmed || lowered === "reset" || lowered === "default" || lowered === "builtin")
-        return undefined;
-    if (["none", "off", "disable", "disabled"].includes(lowered))
-        return null;
-    return trimmed;
-}
-export function formatDefaultPreset(value) {
-    if (value === undefined)
-        return "built-in (pro-search)";
-    return value ?? "none";
-}
-function settingsSnapshot(preferences) {
-    return {
-        ...("defaultPreset" in preferences ? { defaultPreset: preferences.defaultPreset } : {}),
-        ...(preferences.isolation ? { shellIsolation: preferences.isolation } : {}),
-    };
-}
-export function normalizeShellIsolationMode(value) {
-    const lowered = value.trim().toLowerCase();
-    if (lowered === "none" || lowered === "off" || lowered === "disable" || lowered === "disabled")
-        return "none";
-    if (lowered === "auto" || lowered === "default")
-        return "auto";
-    if (lowered === "required" || lowered === "require" || lowered === "strict")
-        return "required";
-    throw new Error("Unknown shell isolation mode. Use none, auto, or required.");
-}
-export function normalizeIsolatorPath(value) {
-    const trimmed = value.trim();
-    if (!trimmed)
-        throw new Error("Usage: /config isolator <path>, or /config isolator none.");
-    const lowered = trimmed.toLowerCase();
-    if (["none", "off", "disable", "disabled", "clear", "reset"].includes(lowered))
-        return null;
-    return trimmed;
-}
-export function normalizeIsolatorSource(value) {
-    const trimmed = value.trim();
-    if (!trimmed)
-        throw new Error("Usage: /config isolator source <https-url>, or /config isolator source none.");
-    const lowered = trimmed.toLowerCase();
-    if (["none", "off", "disable", "disabled", "clear", "reset"].includes(lowered))
-        return null;
-    return normalizeSourceURL(trimmed);
-}
-export function formatShellIsolation(value) {
-    return value?.mode ?? "auto";
-}
-export function formatIsolatorPath(value) {
-    return value?.executablePath || process.env.AGENT_ISOLATOR_PATH || "not configured";
-}
-export function formatIsolatorSource(value) {
-    return value?.sourceURL || "not configured";
-}
-export function effectiveDefaultPreset(preferences, builtInPreset) {
-    if ("defaultPreset" in preferences)
-        return preferences.defaultPreset ?? undefined;
-    return builtInPreset;
-}
-export function formatPresetList(presets, currentPreset) {
-    if (presets.length === 0)
-        return ["- none returned by this endpoint"];
-    return presets.map((preset) => {
-        const description = preset.description ? ` - ${preset.description}` : "";
-        const current = currentPreset && preset.preset === currentPreset;
-        return `${current ? "*" : "-"} ${preset.preset}${current ? " (current)" : ""}${description}`;
-    });
-}
-function shouldApplyDefaultPreset(options) {
-    return !options.presetExplicit && !options.modelExplicit;
-}
-function runConfigText({ accessMode, contextEnabled, defaultPreset, profileName, runModel, runPreset, renderMode, shellIsolation, }) {
-    return [
-        `Profile: ${profileName}`,
-        `Preset: ${runPreset || "none"}`,
-        `Default preset: ${formatDefaultPreset(defaultPreset)}`,
-        `Model: ${runModel || "auto"}`,
-        `Render mode: ${renderMode}`,
-        `Shell isolation: ${formatShellIsolation(shellIsolation)}`,
-        `Isolator path: ${formatIsolatorPath(shellIsolation)}`,
-        `Isolator source: ${formatIsolatorSource(shellIsolation)}`,
-        `local_workdir tool: ${contextEnabled ? "on" : "off"}`,
-        `local_shell tool: ${contextEnabled ? "on" : "off"}`,
-        `Local access: ${accessMode}`,
-    ].join("\n");
-}
-function userFacingError(error) {
-    if (error instanceof Error)
-        return error.message;
-    return String(error);
-}
-async function reconcileConfiguredIsolator(preferences, updatePreferences, installOptions, formatError) {
-    const isolation = preferences.isolation;
-    if (!isolation?.sourceURL || !isolation.executablePath)
-        return { preferences };
-    try {
-        const result = await ensureConfiguredIsolator({
-            sourceURL: isolation.sourceURL,
-            executablePath: isolation.executablePath,
-            sha256: isolation.sha256,
-        }, installOptions);
-        if (!result.repaired)
-            return { preferences };
-        const updated = await updatePreferences({
-            isolation: {
-                sourceURL: result.sourceURL,
-                executablePath: result.executablePath,
-                sha256: result.sha256,
-                installSkipped: false,
-            },
-        });
-        return {
-            preferences: updated,
-            activity: `Reinstalled isolator: ${result.executablePath}`,
-        };
-    }
-    catch (error) {
-        return {
-            preferences,
-            warning: `Configured isolator is unavailable: ${formatError(error)}`,
-        };
-    }
-}

package/dist/workbench/shell-isolation.d.ts

@@ -1,20 +0,0 @@
-export type ShellIsolationMode = "none" | "auto" | "required";
-export interface ShellIsolationPreferences {
-    mode?: ShellIsolationMode;
-    executablePath?: string | null;
-    version?: string | null;
-    sourceURL?: string | null;
-    sha256?: string | null;
-    installSkipped?: boolean | null;
-}
-export declare function localShellIsolationOptions(preferences?: ShellIsolationPreferences): {
-    readonly isolator?: {
-        executablePath: string;
-    } | undefined;
-    readonly isolation: ShellIsolationMode;
-    readonly isolationOptions: {
-        readonly filesystem: "workdir-readwrite";
-        readonly network: "allowed";
-        readonly env: "inherit";
-    };
-};

package/dist/workbench/shell-isolation.js

@@ -1,13 +0,0 @@
-export function localShellIsolationOptions(preferences = {}) {
-    const executablePath = preferences.executablePath?.trim() || process.env.AGENT_ISOLATOR_PATH?.trim();
-    const isolation = preferences.mode ?? "auto";
-    return {
-        isolation,
-        isolationOptions: {
-            filesystem: "workdir-readwrite",
-            network: "allowed",
-            env: "inherit",
-        },
-        ...(executablePath ? { isolator: { executablePath } } : {}),
-    };
-}

package/dist/workbench/turn-controller.d.ts

@@ -1,25 +0,0 @@
-import { resolveRuntimeProfile } from "../profile.js";
-import { resumeAgentAfterLocalApproval, runAgentTurn, type AgentRunOptions, type LocalToolApprovalRequest, type WorkdirAccessMode } from "../agent.js";
-import type { WorkbenchEngine, WorkbenchRuntimeEffect } from "./engine.js";
-import type { WorkbenchAction, WorkbenchState } from "../tui/workbench.js";
-export interface WorkbenchTurnController {
-    startPrompt(prompt: string): Promise<void>;
-    continueAfterLocalApproval(input: {
-        approval: LocalToolApprovalRequest;
-        result: string | Record<string, unknown>;
-        accessMode: WorkdirAccessMode;
-    }): Promise<void>;
-    abort(reason: string): Promise<void>;
-}
-export interface WorkbenchTurnControllerOptions {
-    engine: WorkbenchEngine;
-    baseOptions: AgentRunOptions;
-    dispatch(action: WorkbenchAction): void;
-    getState(): WorkbenchState;
-    runRuntimeEffects(effects: WorkbenchRuntimeEffect[], assistantId: string): void;
-    flushTextDeltaBuffer(): void;
-    runAgentTurnImpl?: typeof runAgentTurn;
-    resumeAgentAfterLocalApprovalImpl?: typeof resumeAgentAfterLocalApproval;
-    resolveRuntimeProfileImpl?: typeof resolveRuntimeProfile;
-}
-export declare function createWorkbenchTurnController(options: WorkbenchTurnControllerOptions): WorkbenchTurnController;

package/dist/workbench/turn-controller.js

@@ -1,164 +0,0 @@
-import { resolveRuntimeProfile, } from "../profile.js";
-import { resumeAgentAfterLocalApproval, runAgentTurn, } from "../agent.js";
-export function createWorkbenchTurnController(options) {
-    const runAgentTurnImpl = options.runAgentTurnImpl ?? runAgentTurn;
-    const resumeAgentAfterLocalApprovalImpl = options.resumeAgentAfterLocalApprovalImpl ?? resumeAgentAfterLocalApproval;
-    const resolveRuntimeProfileImpl = options.resolveRuntimeProfileImpl ?? resolveRuntimeProfile;
-    let activeAbortController = null;
-    let activeResponseID = null;
-    const cancelledResponseIDs = new Set();
-    return {
-        async startPrompt(prompt) {
-            const state = options.getState();
-            const assistantId = `assistant-${Date.now()}`;
-            const abortController = new AbortController();
-            activeAbortController = abortController;
-            activeResponseID = null;
-            options.dispatch({ type: "busy.set", busy: true });
-            options.dispatch({ type: "message.add", role: "user", text: prompt });
-            options.dispatch({ type: "message.add", role: "assistant", text: "", id: assistantId });
-            options.dispatch({ type: "assistant.active", id: assistantId });
-            options.dispatch({ type: "activity.add", text: "Agent turn started" });
-            try {
-                const result = await runAgentTurnImpl({
-                    ...options.baseOptions,
-                    preset: state.runPreset,
-                    model: state.runModel,
-                    promptParts: [prompt],
-                    stream: true,
-                    file: undefined,
-                    stdin: false,
-                    conversation: state.currentConversation,
-                    includeLocalContext: state.contextEnabled,
-                    accessMode: state.accessMode,
-                    shellIsolation: state.shellIsolation,
-                    restartConversation: false,
-                    abortSignal: abortController.signal,
-                }, (event) => handleAgentEvent(event, assistantId));
-                options.dispatch({
-                    type: "activity.add",
-                    level: "success",
-                    text: result.responseID ? `Agent turn completed: ${result.responseID}` : "Agent turn completed",
-                });
-            }
-            catch (error) {
-                handleTurnError(error);
-            }
-            finally {
-                finishTurn(abortController);
-            }
-        },
-        async continueAfterLocalApproval(input) {
-            const state = options.getState();
-            const assistantId = `assistant-${Date.now()}`;
-            const abortController = new AbortController();
-            activeAbortController = abortController;
-            activeResponseID = null;
-            options.dispatch({ type: "busy.set", busy: true });
-            options.dispatch({ type: "message.add", role: "assistant", text: "", id: assistantId });
-            options.dispatch({ type: "assistant.active", id: assistantId });
-            options.dispatch({ type: "activity.add", text: "Continuing agent turn" });
-            try {
-                const continuation = await resumeAgentAfterLocalApprovalImpl({
-                    ...options.baseOptions,
-                    preset: state.runPreset,
-                    model: state.runModel,
-                    stream: true,
-                    file: undefined,
-                    stdin: false,
-                    conversation: state.currentConversation,
-                    includeLocalContext: state.contextEnabled,
-                    accessMode: input.accessMode,
-                    shellIsolation: state.shellIsolation,
-                    restartConversation: false,
-                    abortSignal: abortController.signal,
-                }, input.approval, input.result, (event) => handleAgentEvent(event, assistantId));
-                options.dispatch({
-                    type: "activity.add",
-                    level: "success",
-                    text: continuation.responseID ? `Agent turn continued: ${continuation.responseID}` : "Agent turn continued",
-                });
-            }
-            catch (error) {
-                handleTurnError(error);
-            }
-            finally {
-                finishTurn(abortController);
-            }
-        },
-        async abort(reason) {
-            const state = options.getState();
-            if (!state.busy && !activeAbortController && !activeResponseID) {
-                options.dispatch({ type: "message.add", role: "system", text: "No agent turn is running." });
-                return;
-            }
-            activeAbortController?.abort();
-            options.dispatch({ type: "activity.add", level: "warning", text: reason });
-            if (!activeResponseID) {
-                options.dispatch({ type: "message.add", role: "system", text: "Abort requested. No remote response ID is available yet." });
-                return;
-            }
-            if (cancelledResponseIDs.has(activeResponseID))
-                return;
-            const responseID = activeResponseID;
-            cancelledResponseIDs.add(responseID);
-            try {
-                const runtimeProfile = await resolveRuntimeProfileImpl(options.baseOptions.profile);
-                const result = await runtimeProfile.client.responses.cancel(responseID);
-                options.dispatch({
-                    type: "message.add",
-                    role: "system",
-                    text: result.interrupted
-                        ? `Abort requested for response ${responseID}.`
-                        : `Abort requested locally. Remote response ${responseID} was not actively interrupted.`,
-                });
-                options.dispatch({
-                    type: "activity.add",
-                    level: result.interrupted ? "success" : "warning",
-                    text: result.interrupted ? `Response cancel requested: ${responseID}` : `Response was not active: ${responseID}`,
-                });
-            }
-            catch (error) {
-                options.dispatch({ type: "message.add", role: "system", text: `Abort requested locally, but remote cancel failed: ${userFacingError(error)}` });
-                options.dispatch({ type: "activity.add", level: "error", text: "Remote response cancel failed" });
-            }
-        },
-    };
-    function handleAgentEvent(event, assistantId) {
-        const result = options.engine.handleAgentEvent(event);
-        for (const effect of result.effects) {
-            if (effect.type === "set_active_response_id") {
-                activeResponseID = effect.responseID;
-            }
-        }
-        options.runRuntimeEffects(result.effects, assistantId);
-    }
-    function finishTurn(abortController) {
-        options.flushTextDeltaBuffer();
-        if (activeAbortController === abortController) {
-            activeAbortController = null;
-        }
-        activeResponseID = null;
-        options.dispatch({ type: "busy.set", busy: false });
-        options.dispatch({ type: "assistant.active", id: null });
-    }
-    function handleTurnError(error) {
-        const message = userFacingError(error);
-        const aborted = /aborted/i.test(message);
-        options.dispatch({
-            type: "message.add",
-            role: "system",
-            text: aborted ? "Agent turn aborted." : message,
-        });
-        options.dispatch({
-            type: "activity.add",
-            level: aborted ? "warning" : "error",
-            text: aborted ? "Agent turn aborted" : message,
-        });
-    }
-}
-function userFacingError(error) {
-    if (error instanceof Error)
-        return error.message;
-    return String(error);
-}

package/dist/workbench/view-model.d.ts

@@ -1,34 +0,0 @@
-import type { RenderMode, WorkbenchMessage } from "../tui/workbench.js";
-export type TranscriptLine = {
-    id: string;
-    text: string;
-    color?: string;
-    bold?: boolean;
-    inverse?: boolean;
-};
-export interface TranscriptViewModel {
-    lines: TranscriptLine[];
-    visibleLines: TranscriptLine[];
-    maxOffset: number;
-    offset: number;
-    viewportHeight: number;
-}
-export declare function buildTranscriptViewModel(input: {
-    activeAssistantMessageId: string | null;
-    busy: boolean;
-    messages: WorkbenchMessage[];
-    offset: number;
-    renderMode: RenderMode;
-    spinnerFrame: number;
-    viewportHeight: number;
-    width: number;
-}): TranscriptViewModel;
-export declare function buildTranscriptLines(messages: WorkbenchMessage[], options: {
-    activeAssistantMessageId: string | null;
-    busy: boolean;
-    renderMode: RenderMode;
-    spinnerFrame: number;
-    width: number;
-}): TranscriptLine[];
-export declare function spinnerGlyph(frame: number): string;
-export declare function elapsedDots(frame: number): string;

package/dist/workbench/view-model.js

@@ -1,121 +0,0 @@
-export function buildTranscriptViewModel(input) {
-    const lines = buildTranscriptLines(input.messages, {
-        activeAssistantMessageId: input.activeAssistantMessageId,
-        busy: input.busy,
-        renderMode: input.renderMode,
-        spinnerFrame: input.spinnerFrame,
-        width: input.width,
-    });
-    const maxOffset = Math.max(0, lines.length - input.viewportHeight);
-    const offset = Math.min(input.offset, maxOffset);
-    const start = Math.max(0, lines.length - input.viewportHeight - offset);
-    return {
-        lines,
-        visibleLines: lines.slice(start, start + input.viewportHeight),
-        maxOffset,
-        offset,
-        viewportHeight: input.viewportHeight,
-    };
-}
-export function buildTranscriptLines(messages, options) {
-    const lines = [];
-    for (const message of messages) {
-        const waiting = message.role === "assistant" && options.busy && message.id === options.activeAssistantMessageId && !message.text;
-        lines.push({
-            id: `${message.id}:role`,
-            text: roleLabel(message.role),
-            color: roleColor(message.role),
-        });
-        const content = message.text || (waiting ? `${spinnerGlyph(options.spinnerFrame)} thinking ${elapsedDots(options.spinnerFrame)}` : "");
-        const rendered = options.renderMode === "raw"
-            ? rawTranscriptLines(content, options.width)
-            : markdownTranscriptLines(content, options.width);
-        rendered.forEach((line, index) => {
-            lines.push({
-                ...line,
-                id: `${message.id}:line:${index}`,
-            });
-        });
-        if (message.role !== "system") {
-            lines.push({ id: `${message.id}:space`, text: "" });
-        }
-    }
-    return lines;
-}
-export function spinnerGlyph(frame) {
-    return ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"][frame % 10];
-}
-export function elapsedDots(frame) {
-    return ".".repeat((Math.floor(frame / 4) % 3) + 1);
-}
-function rawTranscriptLines(text, width) {
-    const source = text ? text.split(/\r?\n/) : [""];
-    return source.flatMap((line) => wrapTranscriptText(line, width).map((text) => ({ text })));
-}
-function markdownTranscriptLines(text, width) {
-    const source = text ? text.split(/\r?\n/) : [""];
-    const lines = [];
-    let inCode = false;
-    for (const sourceLine of source) {
-        if (/^\s*```/.test(sourceLine)) {
-            inCode = !inCode;
-            lines.push(...wrapTranscriptText(sourceLine, width).map((line) => ({ text: line, color: "gray" })));
-            continue;
-        }
-        lines.push(...markdownTranscriptLine(sourceLine, { code: inCode, width }));
-    }
-    return lines;
-}
-function markdownTranscriptLine(line, options) {
-    if (line === "")
-        return [{ text: "" }];
-    if (options.code)
-        return wrapTranscriptText(line, options.width).map((text) => ({ text, color: "gray" }));
-    const heading = /^(#{1,6})\s+(.+)$/.exec(line);
-    if (heading) {
-        const color = heading[1].length <= 2 ? "cyan" : "blue";
-        return wrapTranscriptText(heading[2], options.width).map((text) => ({ text, bold: true, color }));
-    }
-    if (/^\s*---+\s*$/.test(line))
-        return [{ text: "─".repeat(Math.min(48, options.width)), color: "gray" }];
-    const bullet = /^(\s*)[-*]\s+(.+)$/.exec(line);
-    if (bullet)
-        return wrapTranscriptText(`${bullet[1]}• ${bullet[2]}`, options.width).map((text) => ({ text }));
-    const numbered = /^(\s*)(\d+\.)\s+(.+)$/.exec(line);
-    if (numbered)
-        return wrapTranscriptText(`${numbered[1]}${numbered[2]} ${numbered[3]}`, options.width).map((text) => ({ text }));
-    const quote = /^\s*>\s?(.+)$/.exec(line);
-    if (quote)
-        return wrapTranscriptText(`│ ${quote[1]}`, options.width).map((text) => ({ text, color: "gray" }));
-    return wrapTranscriptText(line, options.width).map((text) => ({ text }));
-}
-function wrapTranscriptText(text, width) {
-    const max = Math.max(12, width);
-    if (text.length === 0)
-        return [""];
-    const lines = [];
-    let rest = text;
-    while (rest.length > max) {
-        const hard = rest.slice(0, max);
-        const softBreak = Math.max(hard.lastIndexOf(" "), hard.lastIndexOf("\t"));
-        const index = softBreak > Math.floor(max * 0.45) ? softBreak : max;
-        lines.push(rest.slice(0, index).trimEnd());
-        rest = rest.slice(index).trimStart();
-    }
-    lines.push(rest);
-    return lines;
-}
-function roleLabel(role) {
-    if (role === "user")
-        return "You";
-    if (role === "assistant")
-        return "Agent";
-    return "System";
-}
-function roleColor(role) {
-    if (role === "user")
-        return "green";
-    if (role === "assistant")
-        return "cyan";
-    return "gray";
-}