@agent-api/cli 0.2.1 → 0.3.0

package/dist/workbench/isolator-installer.js

@@ -1,208 +0,0 @@
-import { createHash } from "node:crypto";
-import { constants as fsConstants } from "node:fs";
-import { access, chmod, copyFile, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { spawn } from "node:child_process";
-import path from "node:path";
-import { runtime } from "../runtime/index.js";
-export async function installConfiguredIsolator(config, options = {}) {
-    const sourceURL = normalizeSourceURL(config.sourceURL);
-    const executablePath = normalizeInstallPath(config.executablePath);
-    const targetDir = path.dirname(executablePath);
-    const existing = await existingTargetState(executablePath);
-    await mkdir(targetDir, { recursive: true });
-    await ensureWritableDirectory(targetDir);
-    const fetchImpl = options.fetchImpl ?? fetch;
-    const response = await fetchImpl(sourceURL);
-    if (!response.ok) {
-        throw new Error(`isolator download failed: HTTP ${response.status}`);
-    }
-    const body = new Uint8Array(await response.arrayBuffer());
-    if (body.length === 0) {
-        throw new Error("isolator download failed: empty response body");
-    }
-    const actualSha256 = createHash("sha256").update(body).digest("hex");
-    const expectedSha256 = config.sha256?.trim().toLowerCase();
-    if (expectedSha256 && actualSha256 !== expectedSha256) {
-        throw new Error(`isolator checksum mismatch: expected ${expectedSha256}, got ${actualSha256}`);
-    }
-    const tempPath = path.join(targetDir, `.${path.basename(executablePath)}.${process.pid}.${Date.now()}.tmp`);
-    try {
-        await writeFile(tempPath, body, { mode: 0o700 });
-        if (process.platform !== "win32") {
-            await chmod(tempPath, 0o700);
-        }
-        await probeIsolator(tempPath, options.probeTimeoutMs ?? 10_000);
-        await rename(tempPath, executablePath);
-    }
-    catch (error) {
-        await rm(tempPath, { force: true });
-        throw error;
-    }
-    return {
-        executablePath,
-        sourceURL,
-        bytes: body.length,
-        sha256: actualSha256,
-        replaced: existing === "file",
-    };
-}
-export async function validateInstalledIsolator(executablePath, options = {}) {
-    const normalized = normalizeInstallPath(executablePath);
-    const state = await existingTargetState(normalized);
-    if (state !== "file") {
-        throw new Error(`isolator executable does not exist: ${normalized}`);
-    }
-    await probeIsolator(normalized, options.probeTimeoutMs ?? 10_000);
-    return normalized;
-}
-export async function ensureConfiguredIsolator(config, options = {}) {
-    const sourceURL = normalizeSourceURL(config.sourceURL);
-    const executablePath = normalizeInstallPath(config.executablePath);
-    try {
-        await validateInstalledIsolator(executablePath, options);
-        return {
-            executablePath,
-            sourceURL,
-            sha256: config.sha256,
-            repaired: false,
-        };
-    }
-    catch {
-        const result = await installConfiguredIsolator({ sourceURL, executablePath, sha256: config.sha256 }, options);
-        return {
-            executablePath: result.executablePath,
-            sourceURL: result.sourceURL,
-            sha256: result.sha256,
-            repaired: true,
-        };
-    }
-}
-export async function relocateInstalledIsolator(fromPath, toPath, options = {}) {
-    const source = await validateInstalledIsolator(fromPath, options);
-    const target = normalizeInstallPath(toPath);
-    if (source === target)
-        return target;
-    const targetDir = path.dirname(target);
-    await existingTargetState(target);
-    await mkdir(targetDir, { recursive: true });
-    await ensureWritableDirectory(targetDir);
-    const tempPath = path.join(targetDir, `.${path.basename(target)}.${process.pid}.${Date.now()}.tmp`);
-    try {
-        await copyFile(source, tempPath);
-        if (process.platform !== "win32") {
-            await chmod(tempPath, 0o700);
-        }
-        await probeIsolator(tempPath, options.probeTimeoutMs ?? 10_000);
-        await rename(tempPath, target);
-    }
-    catch (error) {
-        await rm(tempPath, { force: true });
-        throw error;
-    }
-    return target;
-}
-export function defaultIsolatorInstallPath() {
-    return path.join(runtime.dirs.data, "bin", process.platform === "win32" ? "agent-isolator.exe" : "agent-isolator");
-}
-export function normalizeSourceURL(value) {
-    const trimmed = value?.trim();
-    if (!trimmed)
-        throw new Error("isolator sourceURL is required");
-    let url;
-    try {
-        url = new URL(trimmed);
-    }
-    catch {
-        throw new Error("isolator sourceURL must be a valid URL");
-    }
-    if (url.protocol !== "https:") {
-        throw new Error("isolator sourceURL must use https");
-    }
-    return url.toString();
-}
-export function normalizeInstallPath(value) {
-    const trimmed = value?.trim();
-    if (!trimmed)
-        throw new Error("isolator executablePath is required");
-    if (!path.isAbsolute(trimmed)) {
-        throw new Error("isolator executablePath must be absolute");
-    }
-    const normalized = path.normalize(trimmed);
-    const root = path.parse(normalized).root;
-    if (normalized === root) {
-        throw new Error("isolator executablePath cannot be a filesystem root");
-    }
-    if (path.basename(normalized).startsWith(".")) {
-        throw new Error("isolator executablePath must not be a hidden temp-style filename");
-    }
-    return normalized;
-}
-async function existingTargetState(file) {
-    try {
-        const info = await stat(file);
-        if (!info.isFile()) {
-            throw new Error(`isolator executablePath exists but is not a file: ${file}`);
-        }
-        return "file";
-    }
-    catch (error) {
-        if (error?.code === "ENOENT")
-            return "missing";
-        throw error;
-    }
-}
-async function ensureWritableDirectory(dir) {
-    try {
-        await access(dir, fsConstants.W_OK);
-    }
-    catch {
-        throw new Error(`isolator target directory is not writable: ${dir}`);
-    }
-}
-async function probeIsolator(executablePath, timeoutMs) {
-    const request = JSON.stringify({ id: "status", method: "status", params: {} });
-    const child = spawn(executablePath, ["--once", "--driver=auto"], {
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true,
-    });
-    const chunks = [];
-    const errors = [];
-    child.stdout.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-    child.stderr.on("data", (chunk) => errors.push(Buffer.from(chunk)));
-    child.stdin.end(`${request}\n`);
-    const code = await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            child.kill();
-            reject(new Error("isolator probe timed out"));
-        }, timeoutMs);
-        child.on("error", (error) => {
-            clearTimeout(timer);
-            reject(error);
-        });
-        child.on("close", (exitCode) => {
-            clearTimeout(timer);
-            resolve(exitCode);
-        });
-    });
-    const stdout = Buffer.concat(chunks).toString("utf8").trim();
-    const stderr = Buffer.concat(errors).toString("utf8").trim();
-    if (code !== 0) {
-        throw new Error(stderr || stdout || `isolator probe failed with exit code ${code}`);
-    }
-    const line = stdout.split(/\r?\n/).find(Boolean);
-    if (!line)
-        throw new Error("isolator probe returned no response");
-    let parsed;
-    try {
-        parsed = JSON.parse(line);
-    }
-    catch {
-        throw new Error("isolator probe returned invalid JSON");
-    }
-    if (parsed?.error) {
-        throw new Error(parsed.error.message || parsed.error.code || "isolator probe failed");
-    }
-    if (!parsed?.result?.status?.driver) {
-        throw new Error("isolator probe response did not include shell isolation status");
-    }
-}

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

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

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

@@ -1,21 +0,0 @@
-import { openWorkdir } from "../workdir/index.js";
-import type { WorkbenchState, WorkbenchWorkdirStatus } from "../tui/workbench.js";
-import type { ShellIsolationPreferences } from "./shell-isolation.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;
-    getShellIsolation?: () => ShellIsolationPreferences | undefined;
-}
-type LocalApprovalLike = NonNullable<WorkbenchState["pendingLocalTool"]>;
-export declare function createWorkbenchLocalController(options?: WorkbenchLocalControllerOptions): WorkbenchLocalController;
-export {};

package/dist/workbench/local-controller.js

@@ -1,94 +0,0 @@
-import { createLocalShellToolRegistry, createLocalWorkdirToolRegistry } from "@agent-api/sdk/local";
-import { openWorkdir } from "../workdir/index.js";
-import { localShellIsolationOptions } from "./shell-isolation.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",
-                ...localShellIsolationOptions(options.getShellIsolation?.()),
-            });
-            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

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

package/dist/workbench/render-model.js

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

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

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

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

@@ -1,42 +0,0 @@
-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({
-        getShellIsolation: () => engine.snapshot().shellIsolation,
-    });
-    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();
-}