@agent-api/app-engine 0.0.1

package/dist/workbench/state.js

@@ -0,0 +1,392 @@
+export function createInitialWorkbenchState(options) {
+    const accessMode = options.accessMode ?? (options.contextEnabled ? "approval" : "off");
+    return {
+        messages: [
+            newMessage("system", "Agent API Workbench is ready. Type /help for commands."),
+        ],
+        activities: [
+            newActivity("info", "Workbench started"),
+        ],
+        busy: false,
+        contextEnabled: options.contextEnabled || accessMode === "approval" || accessMode === "full",
+        workdir: null,
+        activeAssistantMessageId: null,
+        pendingLocalTool: null,
+        accessMode,
+        currentConversation: options.conversation || "default",
+        runPreset: options.preset,
+        runModel: options.model,
+        renderMode: options.renderMode ?? "markdown",
+        defaultPreset: options.defaultPreset,
+        shellIsolation: options.shellIsolation,
+    };
+}
+export function createInputHistory(limit = 100) {
+    const entries = [];
+    let cursor = null;
+    let draftBeforeBrowse = "";
+    return {
+        record(value) {
+            const trimmed = value.trim();
+            if (!trimmed)
+                return;
+            if (entries.at(-1) !== trimmed) {
+                entries.push(trimmed);
+                if (entries.length > limit)
+                    entries.splice(0, entries.length - limit);
+            }
+            cursor = null;
+            draftBeforeBrowse = "";
+        },
+        previous(currentDraft) {
+            if (entries.length === 0)
+                return currentDraft;
+            if (cursor === null) {
+                draftBeforeBrowse = currentDraft;
+                cursor = entries.length - 1;
+            }
+            else {
+                cursor = Math.max(0, cursor - 1);
+            }
+            return entries[cursor] ?? currentDraft;
+        },
+        next(currentDraft) {
+            if (entries.length === 0 || cursor === null)
+                return currentDraft;
+            if (cursor < entries.length - 1) {
+                cursor += 1;
+                return entries[cursor] ?? currentDraft;
+            }
+            cursor = null;
+            const restored = draftBeforeBrowse;
+            draftBeforeBrowse = "";
+            return restored;
+        },
+        reset() {
+            cursor = null;
+            draftBeforeBrowse = "";
+        },
+        values() {
+            return [...entries];
+        },
+    };
+}
+export function workbenchReducer(state, action) {
+    switch (action.type) {
+        case "message.add":
+            return {
+                ...state,
+                messages: [...state.messages, newMessage(action.role, action.text, action.id)],
+            };
+        case "message.append":
+            return {
+                ...state,
+                messages: state.messages.map((message) => message.id === action.id ? { ...message, text: message.text + action.delta } : message),
+            };
+        case "messages.clear":
+            return {
+                ...state,
+                messages: [newMessage("system", "Cleared. Type /help for commands.")],
+            };
+        case "activity.add":
+            return {
+                ...state,
+                activities: [...state.activities, newActivity(action.level ?? "info", action.text)].slice(-20),
+            };
+        case "busy.set":
+            return { ...state, busy: action.busy };
+        case "context.toggle":
+            return setLocalAccess(state, state.contextEnabled ? "off" : "approval");
+        case "context.set":
+            return setLocalAccess(state, action.enabled ? "approval" : "off");
+        case "workdir.set":
+            return {
+                ...state,
+                workdir: action.workdir,
+                activities: [...state.activities, newActivity("success", `Workdir loaded: ${action.workdir.name}`)].slice(-20),
+            };
+        case "assistant.active":
+            return { ...state, activeAssistantMessageId: action.id };
+        case "local_tool.pending.set": {
+            const pending = {
+                ...action.approval,
+                id: `local-${Date.now()}`,
+                createdAt: Date.now(),
+            };
+            return {
+                ...state,
+                pendingLocalTool: pending,
+                activities: [
+                    ...state.activities,
+                    newActivity("warning", `Local approval ready: ${pending.name}${pending.action ? `.${pending.action}` : ""}`),
+                ].slice(-20),
+            };
+        }
+        case "local_tool.pending.clear":
+            return {
+                ...state,
+                pendingLocalTool: null,
+            };
+        case "access.set":
+            return setLocalAccess(state, action.mode);
+        case "conversation.set":
+            return {
+                ...state,
+                currentConversation: action.name,
+                activities: [...state.activities, newActivity("info", `Conversation: ${action.name}`)].slice(-20),
+            };
+        case "settings.set":
+            return {
+                ...state,
+                ...action.settings,
+            };
+        default:
+            return state;
+    }
+}
+function setLocalAccess(state, mode) {
+    return {
+        ...state,
+        accessMode: mode,
+        contextEnabled: mode !== "off",
+        pendingLocalTool: mode === "off" ? null : state.pendingLocalTool,
+        activities: [...state.activities, newActivity(mode === "off" ? "warning" : "success", `Local access: ${mode}`)].slice(-20),
+    };
+}
+export function parseWorkbenchCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("/"))
+        return null;
+    const [name = "", ...rest] = trimmed.slice(1).split(/\s+/);
+    switch (name) {
+        case "abort":
+        case "cancel":
+            return { kind: "abort" };
+        case "quit":
+            return { kind: "quit" };
+        case "exit":
+            return { kind: "quit" };
+        case "help":
+            return { kind: "help" };
+        case "clear":
+            return { kind: "clear" };
+        case "login":
+        case "signin":
+            return { kind: "login" };
+        case "logout":
+        case "signout":
+            return { kind: "logout" };
+        case "delete-profile":
+        case "delete_profile":
+            return { kind: "delete_profile" };
+        case "switch-profile":
+        case "switch_profile":
+            return { kind: "switch_profile", name: rest.join(" ").trim() || undefined };
+        case "auth":
+            return { kind: "auth_status" };
+        case "config":
+        case "settings": {
+            const [field, ...valueParts] = rest;
+            if (!field)
+                return { kind: "config" };
+            if (field === "preset" || field === "isolation" || field === "isolator") {
+                return { kind: "config", field, value: valueParts.join(" ").trim() || undefined };
+            }
+            return { kind: "invalid", command: `${name} ${field}` };
+        }
+        case "render":
+        case "display":
+        case "view": {
+            const mode = rest[0];
+            if (mode === "raw" || mode === "markdown")
+                return { kind: "render", mode };
+            return { kind: "render" };
+        }
+        case "transcript":
+            return { kind: "transcript" };
+        case "export":
+            return { kind: "export", path: rest.join(" ").trim() || undefined };
+        case "context":
+            return { kind: "context", enabled: parseOnOff(rest[0]) };
+        case "access": {
+            const mode = rest[0];
+            if (mode === "off" || mode === "approval" || mode === "full")
+                return { kind: "access", mode };
+            return { kind: "access" };
+        }
+        case "preset": {
+            const value = rest.join(" ").trim();
+            return { kind: "preset", value: value || undefined };
+        }
+        case "model": {
+            const value = rest.join(" ").trim();
+            return { kind: "model", value: value || undefined };
+        }
+        case "workdir":
+        case "local":
+            return { kind: "workdir", enabled: parseOnOff(rest[0]) };
+        case "summary":
+            return { kind: "summary" };
+        case "new":
+        case "thread":
+            return { kind: "new_conversation", name: rest.join(" ").trim() || undefined };
+        case "conversation":
+        case "switch":
+        case "use":
+            if (rest.length === 0)
+                return { kind: "list_conversations" };
+            return { kind: "switch_conversation", name: rest.join(" ").trim() };
+        case "conversations":
+        case "threads":
+            return { kind: "list_conversations" };
+        case "refresh":
+        case "reload":
+        case "refresh-catalog":
+            return { kind: "refresh_catalog" };
+        case "search":
+        case "grep":
+            return { kind: "search", query: rest.join(" ").trim() };
+        case "preview":
+            return { kind: "preview" };
+        case "apply":
+            return { kind: "apply" };
+        case "apply-all":
+        case "yes-all":
+            return { kind: "apply_all" };
+        case "reject":
+            return { kind: "reject" };
+        default:
+            return { kind: "invalid", command: name };
+    }
+}
+export function parsePendingApprovalCommand(input) {
+    const trimmed = input.trim().toLowerCase();
+    if (!trimmed.startsWith("/"))
+        return null;
+    const [name = ""] = trimmed.slice(1).split(/\s+/);
+    switch (name) {
+        case "apply":
+        case "yes":
+            return { kind: "apply" };
+        case "apply-all":
+        case "yes-all":
+            return { kind: "apply_all" };
+        case "reject":
+        case "no":
+            return { kind: "reject" };
+        default:
+            return null;
+    }
+}
+export function helpText() {
+    return [
+        "Commands:",
+        "/auth            show current auth profile",
+        "/login           return to auth gate without deleting profiles",
+        "/logout          leave current session and return to auth gate",
+        "/switch-profile  switch/sign in with a different profile",
+        "/delete-profile  delete current saved profile and return to auth",
+        "/config          show current run configuration and saved defaults",
+        "/render [mode]   show or set output rendering: markdown or raw",
+        "/transcript      show a plain-text transcript preview",
+        "/export [file]   save the plain-text transcript to a file",
+        "/config preset   save default preset; use none/off for no preset, reset for built-in",
+        "/config isolation save shell isolation mode: none, auto, or required",
+        "/config isolator save agent-isolator path; use none/off to clear",
+        "/preset [name]   show or set preset; use none/off to clear",
+        "/model [name]    show or set explicit model; use auto/none/off to clear",
+        "/access [mode]   show or set local tool access: off, approval, or full",
+        "/workdir       show local workdir status",
+        "/workdir on    shortcut for /access approval; /workdir off hides local tools",
+        "/new [name]      start a fresh conversation in this workbench",
+        "/switch <name>   switch to an existing/new conversation handle",
+        "/conversations   list saved local conversation handles",
+        "/summary         show local workdir summary previews",
+        "/search <query>  search text in the local workdir",
+        "/preview         show pending local action preview",
+        "/apply           apply pending local action",
+        "/apply-all       apply pending action and allow future local actions",
+        "/reject          reject pending local action",
+        "/abort           cancel the in-flight agent turn",
+        "/context         toggle local context packaging for each agent turn",
+        "/clear           clear the visible terminal transcript",
+        "/quit            leave the workbench",
+    ].join("\n");
+}
+export function formatTranscript(messages) {
+    return messages
+        .map((message) => {
+        const body = message.text.trimEnd();
+        return body ? `${roleLabel(message.role)}:\n${body}` : `${roleLabel(message.role)}:`;
+    })
+        .join("\n\n")
+        .trimEnd() + "\n";
+}
+export function formatTranscriptPreview(messages, maxLines = 80) {
+    const lines = formatTranscript(messages).trimEnd().split(/\r?\n/);
+    if (lines.length <= maxLines) {
+        return ["Transcript preview:", "", ...lines].join("\n");
+    }
+    return [
+        `Transcript preview: showing last ${maxLines} lines of ${lines.length}. Use /export [file] for the full transcript.`,
+        "",
+        ...lines.slice(-maxLines),
+    ].join("\n");
+}
+function parseOnOff(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.toLowerCase();
+    if (["on", "enable", "enabled", "yes", "true"].includes(normalized))
+        return true;
+    if (["off", "disable", "disabled", "no", "false"].includes(normalized))
+        return false;
+    return undefined;
+}
+export function workdirText(status) {
+    if (!status)
+        return "Workdir summary is still loading.";
+    return [
+        `Workdir: ${status.root}`,
+        `Files: ${status.fileCount}`,
+        `Size: ${formatBytes(status.totalBytes)}`,
+        `Scan truncated: ${status.scanTruncated ? "yes" : "no"}`,
+    ].join("\n");
+}
+export 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`;
+}
+export function activityColor(level) {
+    if (level === "success")
+        return "green";
+    if (level === "warning")
+        return "yellow";
+    if (level === "error")
+        return "red";
+    return "gray";
+}
+function newMessage(role, text, id = randomId()) {
+    return { id, role, text };
+}
+function roleLabel(role) {
+    if (role === "user")
+        return "You";
+    if (role === "assistant")
+        return "Agent";
+    return "System";
+}
+function newActivity(level, text) {
+    return {
+        id: randomId(),
+        level,
+        text,
+        timestamp: Date.now(),
+    };
+}
+function randomId() {
+    return Math.random().toString(36).slice(2);
+}

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 "./state.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,164 @@
+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

@@ -0,0 +1,34 @@
+import type { RenderMode, WorkbenchMessage } from "./state.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;