@agent-api/cli 0.0.3 → 0.1.1

package/dist/workbench/engine.js

@@ -0,0 +1,291 @@
+import { createInitialWorkbenchState, formatTranscript, formatTranscriptPreview, helpText, parsePendingApprovalCommand, parseWorkbenchCommand, workbenchReducer, workdirText, } from "../tui/workbench.js";
+export function createWorkbenchEngine(options) {
+    let state = createInitialWorkbenchState(options);
+    let pendingApprovalInvalidInputs = 0;
+    const listeners = new Set();
+    const notify = () => {
+        for (const listener of listeners)
+            listener();
+    };
+    const dispatch = (action) => {
+        if (action.type === "local_tool.pending.set" || action.type === "local_tool.pending.clear") {
+            pendingApprovalInvalidInputs = 0;
+        }
+        const next = workbenchReducer(state, action);
+        if (Object.is(next, state))
+            return;
+        state = next;
+        notify();
+    };
+    return {
+        snapshot() {
+            return state;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        dispatch,
+        handleCommand(command) {
+            switch (command.kind) {
+                case "quit":
+                    return handled({ type: "exit" });
+                case "login":
+                    return handled({ type: "login" });
+                case "logout":
+                    return handled({ type: "logout" });
+                case "delete_profile":
+                    return handled({ type: "delete_profile" });
+                case "switch_profile":
+                    return handled({ type: "switch_profile", name: command.name });
+                case "auth_status":
+                    return handled({ type: "show_auth_status" });
+                case "export":
+                    return handled({
+                        type: "export_transcript",
+                        path: command.path,
+                        transcript: formatTranscript(state.messages),
+                        conversation: state.currentConversation,
+                    });
+                case "refresh_catalog":
+                    dispatch({ type: "activity.add", level: "success", text: "Preset and tool catalogs refreshed" });
+                    dispatch({ type: "message.add", role: "system", text: "Cleared cached preset and server tool catalogs. The next agent turn will fetch fresh platform configuration." });
+                    return handled({ type: "clear_preset_tool_catalog_cache" });
+                case "invalid":
+                    dispatch({
+                        type: "message.add",
+                        role: "system",
+                        text: `Unknown command: /${command.command}\nType /help for supported commands.`,
+                    });
+                    dispatch({ type: "activity.add", level: "warning", text: `Unknown command: /${command.command}` });
+                    return handled();
+                case "help":
+                    dispatch({ type: "message.add", role: "system", text: helpText() });
+                    return handled();
+                case "clear":
+                    dispatch({ type: "messages.clear" });
+                    return handled();
+                case "render":
+                    if (!command.mode) {
+                        dispatch({ type: "message.add", role: "system", text: `Render mode: ${state.renderMode}. Use /render markdown or /render raw.` });
+                        return handled();
+                    }
+                    dispatch({ type: "settings.set", settings: { renderMode: command.mode } });
+                    dispatch({ type: "activity.add", level: "success", text: `Render mode: ${command.mode}` });
+                    dispatch({ type: "message.add", role: "system", text: `Render mode set to ${command.mode}.` });
+                    return handled();
+                case "transcript":
+                    dispatch({ type: "message.add", role: "system", text: formatTranscriptPreview(state.messages) });
+                    dispatch({ type: "activity.add", level: "success", text: "Transcript preview ready" });
+                    return handled();
+                case "context":
+                    dispatch({ type: "context.set", enabled: command.enabled ?? !state.contextEnabled });
+                    return handled();
+                case "access":
+                    if (!command.mode) {
+                        dispatch({ type: "message.add", role: "system", text: `Local access: ${state.accessMode}. Use /access off, /access approval, or /access full.` });
+                        return handled();
+                    }
+                    dispatch({ type: "access.set", mode: command.mode });
+                    return handled();
+                case "model":
+                    if (!command.value) {
+                        dispatch({ type: "message.add", role: "system", text: `Model: ${state.runModel || "auto"}. Use /model <name> or /model auto.` });
+                        return handled();
+                    }
+                    dispatch({ type: "settings.set", settings: { runModel: normalizeOptionalSetting(command.value, ["auto", "none", "off", "clear"]) } });
+                    dispatch({ type: "activity.add", text: `Model: ${normalizeOptionalSetting(command.value, ["auto", "none", "off", "clear"]) || "auto"}` });
+                    return handled();
+                case "workdir":
+                    if (command.enabled === undefined) {
+                        dispatch({
+                            type: "message.add",
+                            role: "system",
+                            text: [
+                                workdirText(state.workdir),
+                                "",
+                                `local_workdir tool: ${state.contextEnabled ? "on" : "off"}`,
+                                `local_shell tool: ${state.contextEnabled ? "on" : "off"}`,
+                                "Use /access approval or /access full to expose local tools, or /access off to hide them.",
+                            ].join("\n"),
+                        });
+                        return handled();
+                    }
+                    dispatch({ type: "context.set", enabled: command.enabled });
+                    dispatch({
+                        type: "activity.add",
+                        level: command.enabled ? "success" : "warning",
+                        text: `local tools ${command.enabled ? "enabled" : "disabled"}`,
+                    });
+                    dispatch({
+                        type: "message.add",
+                        role: "system",
+                        text: command.enabled
+                            ? "local_workdir and local_shell are now available to the model in approval mode. Use /access full to allow execution without prompts."
+                            : "local tools are now hidden from the model.",
+                    });
+                    return handled();
+                default:
+                    return unhandled();
+            }
+        },
+        handleAgentEvent(event) {
+            switch (event.type) {
+                case "text.delta":
+                    return event.delta ? eventResult({ type: "append_text_delta", delta: event.delta }) : eventResult();
+                case "response.started":
+                    if (event.responseID) {
+                        dispatch({ type: "activity.add", text: `Response started: ${event.responseID}` });
+                        return eventResult({ type: "set_active_response_id", responseID: event.responseID });
+                    }
+                    dispatch({ type: "activity.add", text: "Response started" });
+                    return eventResult();
+                case "response.completed":
+                    dispatch({ type: "activity.add", level: "success", text: event.responseID ? `Response completed: ${event.responseID}` : "Response completed" });
+                    return eventResult({ type: "flush_text_delta_buffer" });
+                case "response.failed":
+                    dispatch({ type: "activity.add", level: "error", text: event.message });
+                    return eventResult({ type: "flush_text_delta_buffer" });
+                case "reasoning.started":
+                    dispatch({ type: "activity.add", text: "Reasoning started" });
+                    return eventResult();
+                case "reasoning.stopped":
+                    dispatch({ type: "activity.add", text: event.thought ? `Reasoning stopped: ${event.thought}` : "Reasoning stopped" });
+                    return eventResult();
+                case "reasoning.search_queries":
+                    dispatch({ type: "activity.add", text: `Search queries: ${event.queries.join(", ") || "none"}` });
+                    return eventResult();
+                case "reasoning.search_results":
+                    dispatch({ type: "activity.add", text: `Search results: ${event.count}` });
+                    return eventResult();
+                case "reasoning.fetch_url_queries":
+                    dispatch({ type: "activity.add", text: `Fetch URLs: ${event.urls.join(", ") || "none"}` });
+                    return eventResult();
+                case "reasoning.fetch_url_results":
+                    dispatch({ type: "activity.add", text: `Fetched URL results: ${event.count}` });
+                    return eventResult();
+                case "tool.completed":
+                    dispatch({ type: "activity.add", level: event.status === "failed" ? "error" : "success", text: `Tool completed: ${event.name}${event.status ? ` (${event.status})` : ""}` });
+                    return eventResult();
+                case "local_tool.completed":
+                    dispatch({
+                        type: "activity.add",
+                        level: event.requiresApproval ? "warning" : "success",
+                        text: `Local tool: ${event.name}${event.action ? `.${event.action}` : ""}${event.requiresApproval ? " (approval required)" : ""}`,
+                    });
+                    return eventResult();
+                case "local_tool.approval_requested":
+                    dispatch({
+                        type: "local_tool.pending.set",
+                        approval: {
+                            name: event.name,
+                            action: event.action,
+                            arguments: event.arguments,
+                            preview: event.preview,
+                            callID: event.callID,
+                            responseID: event.responseID,
+                        },
+                    });
+                    dispatch({ type: "message.add", role: "system", text: formatLocalToolApproval(event) });
+                    return eventResult();
+                case "model.requested":
+                    dispatch({ type: "activity.add", text: `Model requested: ${modelLabel(event.model, event.provider)}` });
+                    return eventResult();
+                case "model.completed":
+                    dispatch({ type: "activity.add", level: "success", text: `Model completed: ${modelLabel(event.model, event.provider)}` });
+                    return eventResult();
+                case "model.failed":
+                    dispatch({ type: "activity.add", level: "error", text: `Model failed: ${modelLabel(event.model, event.provider)}` });
+                    return eventResult();
+                case "step.completed":
+                    dispatch({ type: "activity.add", level: "success", text: `Step completed: ${event.stepType || "step"}` });
+                    return eventResult();
+                case "step.failed":
+                    dispatch({ type: "activity.add", level: "error", text: `Step failed: ${event.stepType || "step"}` });
+                    return eventResult();
+                case "raw":
+                    return eventResult();
+            }
+        },
+        submit(input) {
+            const trimmed = input.trim();
+            if (!trimmed)
+                return { kind: "handled" };
+            if (state.pendingLocalTool) {
+                const command = parsePendingApprovalCommand(trimmed);
+                if (command) {
+                    pendingApprovalInvalidInputs = 0;
+                    return { kind: "command", command };
+                }
+                handleInvalidPendingApprovalInput();
+                return { kind: "handled" };
+            }
+            const command = parseWorkbenchCommand(trimmed);
+            if (command)
+                return { kind: "command", command };
+            return { kind: "prompt", prompt: trimmed };
+        },
+    };
+    function handleInvalidPendingApprovalInput() {
+        pendingApprovalInvalidInputs += 1;
+        const attempts = pendingApprovalInvalidInputs;
+        const maxAttempts = 3;
+        if (attempts >= maxAttempts) {
+            dispatch({
+                type: "message.add",
+                role: "system",
+                text: "Local approval aborted after too many invalid inputs. The pending action was not executed.",
+            });
+            dispatch({ type: "activity.add", level: "warning", text: "Local approval aborted" });
+            dispatch({ type: "local_tool.pending.clear" });
+            pendingApprovalInvalidInputs = 0;
+            return;
+        }
+        dispatch({
+            type: "message.add",
+            role: "system",
+            text: `Local approval is pending. Enter /apply or /yes to execute once, /apply-all or /yes-all to allow future local actions, or /reject or /no to discard. Invalid input ${attempts}/${maxAttempts}.`,
+        });
+        dispatch({ type: "activity.add", level: "warning", text: "Waiting for local approval command" });
+    }
+}
+function handled(...effects) {
+    return { handled: true, effects };
+}
+function unhandled() {
+    return { handled: false, effects: [] };
+}
+function eventResult(...effects) {
+    return { effects };
+}
+function modelLabel(model, provider) {
+    if (model && provider)
+        return `${provider}/${model}`;
+    return model || provider || "unknown";
+}
+function formatLocalToolApproval(event) {
+    const label = `${event.name}${event.action ? `.${event.action}` : ""}`;
+    return [
+        `Local action requires approval: ${label}.`,
+        event.preview ? `Preview:\n${formatPreview(event.preview)}` : undefined,
+        "Review it in the workbench, then use /apply to execute once, /apply-all to allow future local actions, or /reject to discard it.",
+    ].filter(Boolean).join("\n\n");
+}
+function formatPreview(preview) {
+    if (typeof preview === "string")
+        return preview;
+    try {
+        return JSON.stringify(preview, null, 2);
+    }
+    catch {
+        return String(preview);
+    }
+}
+function normalizeOptionalSetting(value, clearValues) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    return clearValues.includes(trimmed.toLowerCase()) ? undefined : trimmed;
+}

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

@@ -0,0 +1,44 @@
+export interface WorkbenchInputKey {
+    backspace?: boolean;
+    ctrl?: boolean;
+    delete?: boolean;
+    downArrow?: boolean;
+    end?: boolean;
+    escape?: boolean;
+    home?: boolean;
+    meta?: boolean;
+    pageDown?: boolean;
+    pageUp?: boolean;
+    return?: boolean;
+    upArrow?: boolean;
+}
+export type WorkbenchInputEffect = {
+    type: "exit";
+} | {
+    type: "scroll";
+    delta: number;
+} | {
+    type: "scroll_top";
+} | {
+    type: "scroll_bottom";
+} | {
+    type: "abort";
+} | {
+    type: "submit";
+    input: string;
+} | {
+    type: "ignored_busy";
+};
+export interface WorkbenchInputResult {
+    draft: string;
+    effects: WorkbenchInputEffect[];
+}
+export interface WorkbenchInputContext {
+    busy: boolean;
+    draft: string;
+    viewportHeight: number;
+}
+export interface WorkbenchInputController {
+    handle(input: string, key: WorkbenchInputKey, context: WorkbenchInputContext): WorkbenchInputResult;
+}
+export declare function createWorkbenchInputController(): WorkbenchInputController;

package/dist/workbench/input-controller.js

@@ -0,0 +1,71 @@
+import { createInputHistory } from "../tui/workbench.js";
+export function createWorkbenchInputController() {
+    const history = createInputHistory();
+    return {
+        handle(input, key, context) {
+            if (key.ctrl && input === "c")
+                return result(context.draft, { type: "exit" });
+            if (key.pageUp || (key.ctrl && input === "u")) {
+                return result(context.draft, { type: "scroll", delta: Math.max(1, Math.floor(context.viewportHeight / 2)) });
+            }
+            if (key.pageDown || (key.ctrl && input === "d")) {
+                return result(context.draft, { type: "scroll", delta: -Math.max(1, Math.floor(context.viewportHeight / 2)) });
+            }
+            if (key.home)
+                return result(context.draft, { type: "scroll_top" });
+            if (key.end)
+                return result(context.draft, { type: "scroll_bottom" });
+            if (key.upArrow)
+                return result(history.previous(context.draft));
+            if (key.downArrow)
+                return result(history.next(context.draft));
+            if (context.busy) {
+                return handleBusyInput(input, key, context.draft, history);
+            }
+            return handleReadyInput(input, key, context.draft, history);
+        },
+    };
+}
+function handleBusyInput(input, key, draft, history) {
+    if (key.escape)
+        return result(draft, { type: "abort" });
+    if (key.return) {
+        const command = draft.trim();
+        history.record(command);
+        if (command === "/abort" || command === "/cancel")
+            return result("", { type: "abort" });
+        if (command)
+            return result("", { type: "ignored_busy" });
+        return result("");
+    }
+    if (key.backspace || key.delete) {
+        history.reset();
+        return result(draft.slice(0, -1));
+    }
+    if (input && !key.ctrl && !key.meta) {
+        history.reset();
+        return result(draft + input);
+    }
+    return result(draft);
+}
+function handleReadyInput(input, key, draft, history) {
+    if (key.return) {
+        const prompt = draft.trim();
+        if (!prompt)
+            return result(draft);
+        history.record(prompt);
+        return result("", { type: "submit", input: prompt });
+    }
+    if (key.backspace || key.delete) {
+        history.reset();
+        return result(draft.slice(0, -1));
+    }
+    if (input && !key.ctrl && !key.meta) {
+        history.reset();
+        return result(draft + input);
+    }
+    return result(draft);
+}
+function result(draft, ...effects) {
+    return { draft, effects };
+}

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

@@ -0,0 +1,30 @@
+import type { WorkbenchAuthController } from "./auth-controller.js";
+import type { WorkbenchAction, WorkbenchWorkdirStatus } from "../tui/workbench.js";
+import { checkForUpdate, formatUpdateNotice, type UpdateCheckResult } from "../update.js";
+export type WorkbenchLifecycleEffect = {
+    type: "dispatch";
+    action: WorkbenchAction;
+} | {
+    type: "close";
+    delayMs: number;
+};
+export interface WorkbenchLifecycleController {
+    maybeCheckForUpdate(): Promise<WorkbenchLifecycleEffect[]>;
+    refreshAuth(profile?: string): Promise<WorkbenchLifecycleEffect[]>;
+    initialPrompt(input: {
+        busy: boolean;
+        promptParts: string[];
+        requiresWorkdir?: boolean;
+        workdir: WorkbenchWorkdirStatus | null;
+    }): string | undefined;
+}
+export interface WorkbenchLifecycleControllerOptions {
+    authController: WorkbenchAuthController;
+    checkForUpdateImpl?: typeof checkForUpdate;
+    formatUpdateNoticeImpl?: typeof formatUpdateNotice;
+    formatError?: (error: unknown) => string;
+    refreshWindowMs?: number;
+    updateCheckEnabled?: boolean;
+}
+export declare function createWorkbenchLifecycleController(options: WorkbenchLifecycleControllerOptions): WorkbenchLifecycleController;
+export declare function updateNoticeEffects(result: UpdateCheckResult | null | undefined, formatNotice?: typeof formatUpdateNotice): WorkbenchLifecycleEffect[];

package/dist/workbench/lifecycle-controller.js

@@ -0,0 +1,75 @@
+import { checkForUpdate, formatUpdateNotice } from "../update.js";
+export function createWorkbenchLifecycleController(options) {
+    const checkForUpdateImpl = options.checkForUpdateImpl ?? checkForUpdate;
+    const formatUpdateNoticeImpl = options.formatUpdateNoticeImpl ?? formatUpdateNotice;
+    const formatError = options.formatError ?? userFacingError;
+    const refreshWindowMs = options.refreshWindowMs ?? 5 * 60_000;
+    const updateCheckEnabled = options.updateCheckEnabled ?? process.env.AGENT_TUI_UPDATE_CHECK !== "0";
+    let updateNoticeShown = false;
+    let authRefreshWarningShown = false;
+    let initialPromptSubmitted = false;
+    return {
+        async maybeCheckForUpdate() {
+            if (updateNoticeShown || !updateCheckEnabled)
+                return [];
+            updateNoticeShown = true;
+            try {
+                const result = await checkForUpdateImpl();
+                return updateNoticeEffects(result, formatUpdateNoticeImpl);
+            }
+            catch {
+                return [];
+            }
+        },
+        async refreshAuth(profile) {
+            try {
+                const result = await options.authController.refresh(profile, refreshWindowMs);
+                if (!result.refreshed)
+                    return [];
+                authRefreshWarningShown = false;
+                return [
+                    { type: "dispatch", action: { type: "activity.add", level: "success", text: "Auth session refreshed" } },
+                ];
+            }
+            catch (error) {
+                if (authRefreshWarningShown)
+                    return [];
+                authRefreshWarningShown = true;
+                return [
+                    {
+                        type: "dispatch",
+                        action: {
+                            type: "message.add",
+                            role: "system",
+                            text: `${formatError(error)}\n\nClosing the workbench because authenticated agent conversations are unavailable.`,
+                        },
+                    },
+                    { type: "dispatch", action: { type: "activity.add", level: "error", text: "Auth session needs login; closing" } },
+                    { type: "close", delayMs: 1500 },
+                ];
+            }
+        },
+        initialPrompt(input) {
+            if (initialPromptSubmitted || input.busy || (input.requiresWorkdir && !input.workdir))
+                return undefined;
+            const prompt = input.promptParts.join(" ").trim();
+            if (!prompt)
+                return undefined;
+            initialPromptSubmitted = true;
+            return prompt;
+        },
+    };
+}
+export function updateNoticeEffects(result, formatNotice = formatUpdateNotice) {
+    if (!result?.updateAvailable)
+        return [];
+    return [
+        { type: "dispatch", action: { type: "activity.add", level: "warning", text: `Update available: ${result.latest}` } },
+        { type: "dispatch", action: { type: "message.add", role: "system", text: formatNotice(result) } },
+    ];
+}
+function userFacingError(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}

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

@@ -0,0 +1,19 @@
+import { openWorkdir } from "../workdir/index.js";
+import type { WorkbenchState, WorkbenchWorkdirStatus } from "../tui/workbench.js";
+export interface WorkbenchLocalController {
+    load(path?: string): Promise<WorkbenchWorkdirStatus>;
+    isLoaded(): boolean;
+    summaryText(): Promise<string>;
+    searchText(query: string): Promise<{
+        text: string;
+        count: number;
+    }>;
+    approvalPreview(approval: LocalApprovalLike): string;
+    applyApproval(approval: LocalApprovalLike): Promise<string | Record<string, unknown>>;
+}
+export interface WorkbenchLocalControllerOptions {
+    openWorkdirImpl?: typeof openWorkdir;
+}
+type LocalApprovalLike = NonNullable<WorkbenchState["pendingLocalTool"]>;
+export declare function createWorkbenchLocalController(options?: WorkbenchLocalControllerOptions): WorkbenchLocalController;
+export {};

package/dist/workbench/local-controller.js

@@ -0,0 +1,89 @@
+import { createLocalShellToolRegistry, createLocalWorkdirToolRegistry } from "@agent-api/sdk/local";
+import { openWorkdir } from "../workdir/index.js";
+export function createWorkbenchLocalController(options = {}) {
+    const openWorkdirImpl = options.openWorkdirImpl ?? openWorkdir;
+    let workdir = null;
+    return {
+        async load(path) {
+            const next = await openWorkdirImpl({ path });
+            const summary = await next.summarize();
+            workdir = next;
+            return {
+                root: next.root,
+                name: next.name,
+                fileCount: summary.file_count,
+                totalBytes: summary.total_bytes,
+                scanTruncated: summary.scan_truncated,
+            };
+        },
+        isLoaded() {
+            return Boolean(workdir);
+        },
+        async summaryText() {
+            const current = requireWorkdir();
+            const summary = await current.summarize();
+            const previews = summary.text_previews
+                .slice(0, 5)
+                .map((preview) => `- ${preview.path} (${formatBytes(preview.size)})`)
+                .join("\n");
+            return [
+                `Workdir summary for ${current.name}`,
+                `Files: ${summary.file_count}`,
+                `Size: ${formatBytes(summary.total_bytes)}`,
+                previews ? `Previews:\n${previews}` : "No text previews available.",
+            ].join("\n");
+        },
+        async searchText(query) {
+            const trimmed = query.trim();
+            if (!trimmed) {
+                return { text: "Usage: /search <query>", count: 0 };
+            }
+            const current = requireWorkdir();
+            const results = await current.workdir.grep({ pattern: trimmed, limit: 12 });
+            const matches = results.matches
+                .map((match) => `${match.path}:${match.line_number}: ${match.line.trim()}`)
+                .join("\n");
+            return {
+                text: matches || `No matches for "${trimmed}".`,
+                count: results.matches.length,
+            };
+        },
+        approvalPreview(approval) {
+            return formatLocalToolApproval(approval);
+        },
+        async applyApproval(approval) {
+            const current = requireWorkdir();
+            const workdirRegistry = createLocalWorkdirToolRegistry(current.workdir, { accessMode: "full" });
+            const shellRegistry = createLocalShellToolRegistry({ workdir: current.workdir, accessMode: "full" });
+            if (approval.name === workdirRegistry.toolName) {
+                return await workdirRegistry.execute(approval.name, approval.arguments);
+            }
+            if (approval.name === shellRegistry.toolName) {
+                return await shellRegistry.execute(approval.name, approval.arguments);
+            }
+            throw new Error(`no local handler registered for function ${approval.name}`);
+        },
+    };
+    function requireWorkdir() {
+        if (!workdir)
+            throw new Error("Workdir is still loading.");
+        return workdir;
+    }
+}
+function formatLocalToolApproval(approval) {
+    return [
+        `Local approval requested: ${approval.name}${approval.action ? `.${approval.action}` : ""}`,
+        "Arguments:",
+        JSON.stringify(approval.arguments, null, 2),
+        approval.preview ? ["Preview:", JSON.stringify(approval.preview, null, 2)].join("\n") : "",
+        "",
+        "Use /apply to execute this action once, /apply-all to allow future local actions, or /reject to discard it.",
+    ].filter(Boolean).join("\n");
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+}

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

@@ -0,0 +1,46 @@
+import type { RenderMode, WorkbenchState } from "../tui/workbench.js";
+import { type TranscriptViewModel } from "./view-model.js";
+export interface WorkbenchRendererViewport {
+    rows: number;
+    columns: number;
+}
+export interface WorkbenchRenderModel {
+    activityHeight: number;
+    footerText: string;
+    header: {
+        accessMode: string;
+        contextEnabled: boolean;
+        conversation: string;
+        model: string;
+        pendingLocalLabel: string;
+        preset: string;
+        profile: string;
+        renderMode: RenderMode;
+        workdir: string;
+    };
+    input: {
+        busy: boolean;
+        draft: string;
+        fullAccess: boolean;
+        label: string;
+        waitingText: string;
+    };
+    terminalColumns: number;
+    terminalRows: number;
+    transcript: TranscriptViewModel;
+    transcriptWidth: number;
+    viewportHeight: number;
+    visibleActivities: WorkbenchState["activities"];
+}
+export interface BuildWorkbenchRenderModelInput {
+    draft: string;
+    profileName: string;
+    spinnerFrame: number;
+    state: WorkbenchState;
+    transcriptOffset: number;
+    viewport: Partial<WorkbenchRendererViewport>;
+    workdirFallback: string;
+}
+export declare function buildWorkbenchRenderModel(input: BuildWorkbenchRenderModelInput): WorkbenchRenderModel;
+export declare function pendingLocalLabel(state: WorkbenchState): string;
+export declare function busySpinner(frame: number): string;