@agent-api/cli 0.0.3 → 0.1.1

package/dist/workbench/render-model.js

@@ -0,0 +1,61 @@
+import { buildTranscriptViewModel, elapsedDots, spinnerGlyph, } from "./view-model.js";
+export function buildWorkbenchRenderModel(input) {
+    const terminalRows = Math.max(18, input.viewport.rows || 32);
+    const terminalColumns = Math.max(80, input.viewport.columns || 100);
+    const viewportHeight = Math.max(6, terminalRows - 11);
+    const activityHeight = viewportHeight;
+    const transcriptWidth = Math.max(36, Math.floor(terminalColumns * 0.72) - 4);
+    const transcript = buildTranscriptViewModel({
+        activeAssistantMessageId: input.state.activeAssistantMessageId,
+        busy: input.state.busy,
+        messages: input.state.messages,
+        offset: input.transcriptOffset,
+        renderMode: input.state.renderMode,
+        spinnerFrame: input.spinnerFrame,
+        viewportHeight,
+        width: transcriptWidth,
+    });
+    return {
+        activityHeight,
+        footerText: [
+            "PgUp/PgDn scroll",
+            "End live",
+            "/export save",
+            "/transcript preview",
+            transcript.offset > 0 ? `${transcript.offset} rows from latest` : "live",
+        ].join(" · "),
+        header: {
+            accessMode: input.state.accessMode,
+            contextEnabled: input.state.contextEnabled,
+            conversation: input.state.currentConversation,
+            model: input.state.runModel || "auto",
+            pendingLocalLabel: pendingLocalLabel(input.state),
+            preset: input.state.runPreset || "none",
+            profile: input.profileName,
+            renderMode: input.state.renderMode,
+            workdir: input.state.workdir?.root || input.workdirFallback,
+        },
+        input: {
+            busy: input.state.busy,
+            draft: input.draft,
+            fullAccess: input.state.accessMode === "full",
+            label: input.state.busy ? "working" : "you",
+            waitingText: `waiting for agent ${elapsedDots(input.spinnerFrame)}`,
+        },
+        terminalColumns,
+        terminalRows,
+        transcript,
+        transcriptWidth,
+        viewportHeight,
+        visibleActivities: input.state.activities.slice(-Math.max(1, activityHeight - 2)),
+    };
+}
+export function pendingLocalLabel(state) {
+    if (state.pendingLocalTool) {
+        return `${state.pendingLocalTool.name}${state.pendingLocalTool.action ? `.${state.pendingLocalTool.action}` : ""}`;
+    }
+    return "none";
+}
+export function busySpinner(frame) {
+    return spinnerGlyph(frame);
+}

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

@@ -0,0 +1,12 @@
+import type { WorkbenchAction } from "../tui/workbench.js";
+import type { WorkbenchRuntimeEffect } from "./engine.js";
+export interface WorkbenchRuntimeController {
+    dispose(): void;
+    flushTextDeltaBuffer(): void;
+    runEffects(effects: WorkbenchRuntimeEffect[], assistantId: string): void;
+}
+export interface WorkbenchRuntimeControllerOptions {
+    dispatch(action: WorkbenchAction): void;
+    flushDelayMs?: number;
+}
+export declare function createWorkbenchRuntimeController(options: WorkbenchRuntimeControllerOptions): WorkbenchRuntimeController;

package/dist/workbench/runtime-controller.js

@@ -0,0 +1,57 @@
+export function createWorkbenchRuntimeController(options) {
+    let textDeltaBuffer = null;
+    let textDeltaFlushTimer = null;
+    const flushDelayMs = options.flushDelayMs ?? 80;
+    return {
+        dispose() {
+            if (textDeltaFlushTimer) {
+                clearTimeout(textDeltaFlushTimer);
+                textDeltaFlushTimer = null;
+            }
+            textDeltaBuffer = null;
+        },
+        flushTextDeltaBuffer,
+        runEffects(effects, assistantId) {
+            for (const effect of effects) {
+                switch (effect.type) {
+                    case "append_text_delta":
+                        appendTextDeltaBuffered(assistantId, effect.delta);
+                        break;
+                    case "set_active_response_id":
+                        break;
+                    case "flush_text_delta_buffer":
+                        flushTextDeltaBuffer();
+                        break;
+                }
+            }
+        },
+    };
+    function appendTextDeltaBuffered(id, delta) {
+        if (!delta)
+            return;
+        if (!textDeltaBuffer || textDeltaBuffer.id !== id) {
+            flushTextDeltaBuffer();
+            textDeltaBuffer = { id, text: delta };
+        }
+        else {
+            textDeltaBuffer.text += delta;
+        }
+        if (textDeltaFlushTimer)
+            return;
+        textDeltaFlushTimer = setTimeout(() => {
+            textDeltaFlushTimer = null;
+            flushTextDeltaBuffer();
+        }, flushDelayMs);
+    }
+    function flushTextDeltaBuffer() {
+        if (textDeltaFlushTimer) {
+            clearTimeout(textDeltaFlushTimer);
+            textDeltaFlushTimer = null;
+        }
+        if (!textDeltaBuffer || !textDeltaBuffer.text)
+            return;
+        const buffered = textDeltaBuffer;
+        textDeltaBuffer = null;
+        options.dispatch({ type: "message.append", id: buffered.id, delta: buffered.text });
+    }
+}

package/dist/workbench/session.d.ts

@@ -0,0 +1,27 @@
+import type { AgentRunOptions } from "../agent.js";
+import type { WorkbenchState } from "../tui/workbench.js";
+import type { WorkbenchAuthController } from "./auth-controller.js";
+import { type WorkbenchConversationController } from "./conversation-controller.js";
+import { type WorkbenchEngine } from "./engine.js";
+import { type WorkbenchInputController } from "./input-controller.js";
+import { type WorkbenchLifecycleController } from "./lifecycle-controller.js";
+import { type WorkbenchLocalController } from "./local-controller.js";
+import { type WorkbenchRuntimeController } from "./runtime-controller.js";
+import { type WorkbenchSettingsController } from "./settings-controller.js";
+import { type WorkbenchTurnController } from "./turn-controller.js";
+export interface WorkbenchSession {
+    conversation: WorkbenchConversationController;
+    engine: WorkbenchEngine;
+    input: WorkbenchInputController;
+    lifecycle: WorkbenchLifecycleController;
+    local: WorkbenchLocalController;
+    runtime: WorkbenchRuntimeController;
+    settings: WorkbenchSettingsController;
+    turn: WorkbenchTurnController;
+}
+export interface WorkbenchSessionOptions {
+    authController: WorkbenchAuthController;
+    baseOptions: AgentRunOptions;
+}
+export declare function createWorkbenchSession(options: WorkbenchSessionOptions): WorkbenchSession;
+export declare function sessionState(session: Pick<WorkbenchSession, "engine">): WorkbenchState;

package/dist/workbench/session.js

@@ -0,0 +1,40 @@
+import { createWorkbenchConversationController } from "./conversation-controller.js";
+import { createWorkbenchEngine } from "./engine.js";
+import { createWorkbenchInputController } from "./input-controller.js";
+import { createWorkbenchLifecycleController } from "./lifecycle-controller.js";
+import { createWorkbenchLocalController } from "./local-controller.js";
+import { createWorkbenchRuntimeController } from "./runtime-controller.js";
+import { createWorkbenchSettingsController } from "./settings-controller.js";
+import { createWorkbenchTurnController } from "./turn-controller.js";
+export function createWorkbenchSession(options) {
+    const engine = createWorkbenchEngine({
+        accessMode: options.baseOptions.accessMode,
+        conversation: options.baseOptions.conversation,
+        contextEnabled: Boolean(options.baseOptions.includeLocalContext || options.baseOptions.workdir),
+        model: options.baseOptions.model,
+        preset: options.baseOptions.preset,
+    });
+    const local = createWorkbenchLocalController();
+    const runtime = createWorkbenchRuntimeController({ dispatch: engine.dispatch });
+    const turn = createWorkbenchTurnController({
+        baseOptions: options.baseOptions,
+        dispatch: engine.dispatch,
+        engine,
+        flushTextDeltaBuffer: runtime.flushTextDeltaBuffer,
+        getState: engine.snapshot,
+        runRuntimeEffects: runtime.runEffects,
+    });
+    return {
+        conversation: createWorkbenchConversationController(),
+        engine,
+        input: createWorkbenchInputController(),
+        lifecycle: createWorkbenchLifecycleController({ authController: options.authController }),
+        local,
+        runtime,
+        settings: createWorkbenchSettingsController(),
+        turn,
+    };
+}
+export function sessionState(session) {
+    return session.engine.snapshot();
+}

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

@@ -0,0 +1,52 @@
+import { clearPresetToolCatalogCache, isAvailablePreset, listAvailablePresets, type AgentRunOptions } from "../agent.js";
+import { loadWorkbenchPreferences, updateWorkbenchPreferences, type WorkbenchPreferences } from "../config.js";
+import type { RenderMode } from "../tui/workbench.js";
+export interface WorkbenchSettingsSnapshot {
+    defaultPreset?: string | null;
+    runPreset?: string;
+}
+export interface WorkbenchSettingsController {
+    loadInitial(options: Pick<AgentRunOptions, "modelExplicit" | "preset" | "presetExplicit">): Promise<WorkbenchSettingsSnapshot>;
+    saveDefaultPreset(input: {
+        value: string;
+        profileName?: string;
+        options: Pick<AgentRunOptions, "modelExplicit" | "preset" | "presetExplicit">;
+    }): Promise<WorkbenchSettingsSnapshot & {
+        message: string;
+        activity: string;
+    }>;
+    validatePreset(profileName: string | undefined, preset: string): Promise<boolean>;
+    presetListText(input: {
+        profileName?: string;
+        currentPreset?: string;
+        prefix: string;
+    }): Promise<string>;
+    configText(input: {
+        accessMode: string;
+        contextEnabled: boolean;
+        defaultPreset?: string | null;
+        profileName: string;
+        runModel?: string;
+        runPreset?: string;
+        renderMode: RenderMode;
+    }): string;
+    defaultPresetHelp(defaultPreset?: string | null): string;
+    clearPresetToolCatalogCache(baseURL?: string): void;
+}
+export interface WorkbenchSettingsControllerOptions {
+    loadWorkbenchPreferencesImpl?: typeof loadWorkbenchPreferences;
+    updateWorkbenchPreferencesImpl?: typeof updateWorkbenchPreferences;
+    isAvailablePresetImpl?: typeof isAvailablePreset;
+    listAvailablePresetsImpl?: typeof listAvailablePresets;
+    clearPresetToolCatalogCacheImpl?: typeof clearPresetToolCatalogCache;
+    formatError?: (error: unknown) => string;
+}
+export declare function createWorkbenchSettingsController(options?: WorkbenchSettingsControllerOptions): WorkbenchSettingsController;
+export declare class UnknownPresetError extends Error {
+    readonly preset: string;
+    constructor(preset: string);
+}
+export declare function normalizeDefaultPreset(value: string): string | null | undefined;
+export declare function formatDefaultPreset(value: string | null | undefined): string;
+export declare function effectiveDefaultPreset(preferences: WorkbenchPreferences, builtInPreset?: string): string | undefined;
+export declare function formatPresetList(presets: Awaited<ReturnType<typeof listAvailablePresets>>, currentPreset?: string): string[];

package/dist/workbench/settings-controller.js

@@ -0,0 +1,120 @@
+import { clearPresetToolCatalogCache, isAvailablePreset, listAvailablePresets, } from "../agent.js";
+import { loadWorkbenchPreferences, updateWorkbenchPreferences, } from "../config.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 formatError = options.formatError ?? userFacingError;
+    return {
+        async loadInitial(agentOptions) {
+            const preferences = await loadWorkbenchPreferencesImpl();
+            return {
+                defaultPreset: preferences.defaultPreset,
+                runPreset: shouldApplyDefaultPreset(agentOptions)
+                    ? effectiveDefaultPreset(preferences, agentOptions.preset)
+                    : undefined,
+            };
+        },
+        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,
+                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.`;
+        },
+        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";
+}
+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, }) {
+    return [
+        `Profile: ${profileName}`,
+        `Preset: ${runPreset || "none"}`,
+        `Default preset: ${formatDefaultPreset(defaultPreset)}`,
+        `Model: ${runModel || "auto"}`,
+        `Render mode: ${renderMode}`,
+        `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);
+}

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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,162 @@
+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,
+                    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,
+                    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

@@ -0,0 +1,34 @@
+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;