@agent-api/app-engine 0.0.1

package/dist/chat-options.js

@@ -0,0 +1,42 @@
+export function normalizeChatOptions(promptParts, options) {
+    const presetExplicit = options.preset !== undefined;
+    const modelExplicit = options.model !== undefined && options.model !== "";
+    const preset = presetExplicit ? options.preset : (modelExplicit ? undefined : "pro-search");
+    const parsedAccessMode = parseAccessMode(options.access);
+    const accessMode = parsedAccessMode ?? (options.workdir || options.localContext ? "approval" : undefined);
+    return {
+        profile: options.profile,
+        promptParts,
+        file: options.file,
+        stdin: options.stdin,
+        preset,
+        presetExplicit,
+        model: options.model,
+        modelExplicit,
+        stream: options.stream !== false,
+        conversation: options.conversation || "default",
+        continueConversation: true,
+        restartConversation: options.restart,
+        workdir: options.workdir,
+        includeLocalContext: options.localContext,
+        contextQuery: options.contextQuery,
+        maxContextFiles: optionalNumber(options.maxContextFiles, "--max-context-files"),
+        maxContextBytes: optionalNumber(options.maxContextBytes, "--max-context-bytes"),
+        accessMode,
+    };
+}
+function optionalNumber(value, label) {
+    if (value == null || value === "")
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        throw new Error(`${label} must be a number`);
+    return parsed;
+}
+function parseAccessMode(value) {
+    if (!value)
+        return undefined;
+    if (value === "off" || value === "approval" || value === "full")
+        return value;
+    throw new Error("--access must be off, approval, or full");
+}

package/dist/config.d.ts

@@ -0,0 +1,66 @@
+import type { ShellIsolationMode, ShellIsolationPreferences } from "./workbench/shell-isolation.js";
+export declare const defaultBaseURL = "https://api.agentsway.dev";
+export declare const configFile = "profiles.json";
+export declare const appConfigurationFile = "configuration.json";
+export declare const conversationsFile = "conversations.json";
+export type AuthProfile = {
+    type: "api_key";
+    apiKey: string;
+} | {
+    type: "browser";
+    accessToken: string;
+    refreshToken: string;
+    accessTokenExpiresAt: number;
+    refreshTokenExpiresAt?: number;
+};
+export interface Profile {
+    name: string;
+    baseURL: string;
+    auth: AuthProfile;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface CLIConfig {
+    activeProfile: string;
+    profiles: Record<string, Profile>;
+}
+export interface ConversationState {
+    name: string;
+    profile: string;
+    previousResponseId?: string;
+    updatedAt: number;
+}
+export interface WorkbenchPreferences {
+    defaultPreset?: string | null;
+    isolation?: ShellIsolationPreferences;
+}
+export interface AppConfiguration {
+    workbench: WorkbenchPreferences;
+}
+export interface ConversationConfiguration {
+    conversations: Record<string, ConversationState>;
+}
+export declare function loadConfig(): Promise<CLIConfig>;
+export declare function saveConfig(config: CLIConfig): Promise<void>;
+export declare function loadAppConfiguration(): Promise<AppConfiguration>;
+export declare function saveAppConfiguration(config: AppConfiguration): Promise<void>;
+export declare function loadConversationConfiguration(): Promise<ConversationConfiguration>;
+export declare function saveConversationConfiguration(config: ConversationConfiguration): Promise<void>;
+export declare function upsertProfile(profile: Omit<Profile, "createdAt" | "updatedAt">): Promise<Profile>;
+export declare function activeProfile(profileName?: string): Promise<Profile>;
+export declare function emptyConfig(): CLIConfig;
+export declare function emptyAppConfiguration(): AppConfiguration;
+export declare function emptyConversationConfiguration(): ConversationConfiguration;
+export declare function loadWorkbenchPreferences(): Promise<WorkbenchPreferences>;
+export declare function updateWorkbenchPreferences(patch: {
+    defaultPreset?: string | null | undefined;
+    isolation?: {
+        mode?: ShellIsolationMode | null | undefined;
+        executablePath?: string | null | undefined;
+        version?: string | null | undefined;
+        sourceURL?: string | null | undefined;
+        sha256?: string | null | undefined;
+        installSkipped?: boolean | null | undefined;
+    };
+}): Promise<WorkbenchPreferences>;
+export declare function redactSecret(value: string): string;

package/dist/config.js

@@ -0,0 +1,201 @@
+import { z } from "zod";
+import { ensureRuntime, runtime } from "./runtime/index.js";
+export const defaultBaseURL = "https://api.agentsway.dev";
+export const configFile = "profiles.json";
+export const appConfigurationFile = "configuration.json";
+export const conversationsFile = "conversations.json";
+const authProfileSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("api_key"),
+        apiKey: z.string(),
+    }),
+    z.object({
+        type: z.literal("browser"),
+        accessToken: z.string(),
+        refreshToken: z.string(),
+        accessTokenExpiresAt: z.number(),
+        refreshTokenExpiresAt: z.number().optional(),
+    }),
+]);
+const profileSchema = z.object({
+    name: z.string(),
+    baseURL: z.string(),
+    auth: authProfileSchema,
+    createdAt: z.number(),
+    updatedAt: z.number(),
+});
+const conversationSchema = z.object({
+    name: z.string(),
+    profile: z.string(),
+    previousResponseId: z.string().optional(),
+    updatedAt: z.number(),
+});
+const workbenchPreferencesSchema = z.object({
+    defaultPreset: z.string().nullable().optional(),
+    isolation: z.object({
+        mode: z.enum(["none", "auto", "required"]).optional(),
+        executablePath: z.string().nullable().optional(),
+        version: z.string().nullable().optional(),
+        sourceURL: z.string().nullable().optional(),
+        sha256: z.string().nullable().optional(),
+        installSkipped: z.boolean().nullable().optional(),
+    }).optional(),
+}).default({});
+const cliConfigSchema = z.object({
+    activeProfile: z.string().default("default"),
+    profiles: z.record(z.string(), profileSchema).default({}),
+    conversations: z.record(z.string(), conversationSchema).default({}),
+});
+const appConfigurationSchema = z.object({
+    workbench: workbenchPreferencesSchema,
+});
+const conversationConfigurationSchema = z.object({
+    conversations: z.record(z.string(), conversationSchema).default({}),
+});
+export async function loadConfig() {
+    await ensureRuntime();
+    const loaded = await runtime.config.read(configFile, emptyConfig());
+    const parsed = cliConfigSchema.safeParse(loaded);
+    if (!parsed.success) {
+        throw new Error(`Invalid CLI config: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+    }
+    return parsed.data;
+}
+export async function saveConfig(config) {
+    await ensureRuntime();
+    await runtime.config.write(configFile, {
+        activeProfile: config.activeProfile,
+        profiles: config.profiles,
+    });
+}
+export async function loadAppConfiguration() {
+    await ensureRuntime();
+    const loaded = await runtime.config.read(appConfigurationFile, emptyAppConfiguration());
+    const parsed = appConfigurationSchema.safeParse(loaded);
+    if (!parsed.success) {
+        throw new Error(`Invalid app configuration: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+    }
+    return parsed.data;
+}
+export async function saveAppConfiguration(config) {
+    await ensureRuntime();
+    await runtime.config.write(appConfigurationFile, config);
+}
+export async function loadConversationConfiguration() {
+    await ensureRuntime();
+    const loaded = await runtime.config.read(conversationsFile, emptyConversationConfiguration());
+    const parsed = conversationConfigurationSchema.safeParse(loaded);
+    if (!parsed.success) {
+        throw new Error(`Invalid conversation configuration: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+    }
+    return parsed.data;
+}
+export async function saveConversationConfiguration(config) {
+    await ensureRuntime();
+    await runtime.config.write(conversationsFile, config);
+}
+export async function upsertProfile(profile) {
+    const config = await loadConfig();
+    const now = Math.floor(Date.now() / 1000);
+    const existing = config.profiles[profile.name];
+    const next = {
+        ...profile,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+    };
+    config.profiles[profile.name] = next;
+    config.activeProfile = profile.name;
+    await saveConfig(config);
+    return next;
+}
+export async function activeProfile(profileName) {
+    const config = await loadConfig();
+    const name = profileName || config.activeProfile || "default";
+    const profile = config.profiles[name];
+    if (!profile) {
+        throw new Error(`Profile not found: ${name}. Run agent-api login first.`);
+    }
+    return profile;
+}
+export function emptyConfig() {
+    return { activeProfile: "default", profiles: {} };
+}
+export function emptyAppConfiguration() {
+    return { workbench: {} };
+}
+export function emptyConversationConfiguration() {
+    return { conversations: {} };
+}
+export async function loadWorkbenchPreferences() {
+    const appConfig = await loadAppConfiguration();
+    return appConfig.workbench;
+}
+export async function updateWorkbenchPreferences(patch) {
+    const appConfig = await loadAppConfiguration();
+    const next = { ...appConfig.workbench };
+    if ("defaultPreset" in patch) {
+        if (patch.defaultPreset === undefined) {
+            delete next.defaultPreset;
+        }
+        else if (patch.defaultPreset === null) {
+            next.defaultPreset = null;
+        }
+        else {
+            const value = patch.defaultPreset.trim();
+            if (value) {
+                next.defaultPreset = value;
+            }
+            else {
+                delete next.defaultPreset;
+            }
+        }
+    }
+    if ("isolation" in patch) {
+        next.isolation = updateIsolationPreferences(next.isolation, patch.isolation);
+    }
+    appConfig.workbench = next;
+    await saveAppConfiguration(appConfig);
+    return next;
+}
+function updateIsolationPreferences(current, patch) {
+    const next = { ...(current ?? {}) };
+    if (!patch)
+        return Object.keys(next).length > 0 ? next : undefined;
+    if ("mode" in patch) {
+        if (patch.mode === null || patch.mode === undefined) {
+            delete next.mode;
+        }
+        else {
+            next.mode = patch.mode;
+        }
+    }
+    for (const key of ["executablePath", "version", "sourceURL", "sha256"]) {
+        if (key in patch) {
+            const value = patch[key];
+            if (value === undefined || value === null) {
+                delete next[key];
+            }
+            else {
+                const trimmed = value.trim();
+                if (trimmed)
+                    next[key] = trimmed;
+                else
+                    delete next[key];
+            }
+        }
+    }
+    if ("installSkipped" in patch) {
+        if (patch.installSkipped === undefined || patch.installSkipped === null) {
+            delete next.installSkipped;
+        }
+        else {
+            next.installSkipped = patch.installSkipped;
+        }
+    }
+    return Object.keys(next).length > 0 ? next : undefined;
+}
+export function redactSecret(value) {
+    if (value.length <= 10)
+        return "***";
+    return `${value.slice(0, 6)}…${value.slice(-4)}`;
+}

package/dist/conversation/index.d.ts

@@ -0,0 +1,17 @@
+import type { ConversationState } from "../config.js";
+export declare function conversationKey(profile: string, name: string): string;
+export declare function resolvePreviousResponseID(options: {
+    profile?: string;
+    conversation?: string;
+    continueConversation?: boolean;
+    restartConversation?: boolean;
+    previousResponseId?: string;
+}): Promise<string | undefined>;
+export declare function updateConversation(options: {
+    profile?: string;
+    conversation?: string;
+}, responseID: string): Promise<void>;
+export declare function listConversations(profileName?: string): Promise<ConversationState[]>;
+export declare function getConversation(name: string, profileName?: string): Promise<ConversationState>;
+export declare function deleteConversation(name: string, profileName?: string): Promise<void>;
+export declare function conversationSummary(conversation: ConversationState): string;

package/dist/conversation/index.js

@@ -0,0 +1,54 @@
+import { activeProfile, loadConversationConfiguration, saveConversationConfiguration } from "../config.js";
+export function conversationKey(profile, name) {
+    return `${profile}:${name}`;
+}
+export async function resolvePreviousResponseID(options) {
+    if (options.previousResponseId)
+        return options.previousResponseId;
+    if (options.restartConversation || !options.conversation)
+        return undefined;
+    if (!options.continueConversation)
+        return undefined;
+    const profile = await activeProfile(options.profile);
+    const config = await loadConversationConfiguration();
+    return config.conversations[conversationKey(profile.name, options.conversation)]?.previousResponseId;
+}
+export async function updateConversation(options, responseID) {
+    if (!options.conversation)
+        return;
+    const profile = await activeProfile(options.profile);
+    const config = await loadConversationConfiguration();
+    config.conversations[conversationKey(profile.name, options.conversation)] = {
+        name: options.conversation,
+        profile: profile.name,
+        previousResponseId: responseID,
+        updatedAt: Math.floor(Date.now() / 1000),
+    };
+    await saveConversationConfiguration(config);
+}
+export async function listConversations(profileName) {
+    const profile = await activeProfile(profileName);
+    const config = await loadConversationConfiguration();
+    return Object.values(config.conversations)
+        .filter((conversation) => conversation.profile === profile.name)
+        .sort((a, b) => b.updatedAt - a.updatedAt);
+}
+export async function getConversation(name, profileName) {
+    const profile = await activeProfile(profileName);
+    const config = await loadConversationConfiguration();
+    const conversation = config.conversations[conversationKey(profile.name, name)];
+    if (!conversation)
+        throw new Error(`Conversation not found: ${name}`);
+    return conversation;
+}
+export async function deleteConversation(name, profileName) {
+    const profile = await activeProfile(profileName);
+    const config = await loadConversationConfiguration();
+    delete config.conversations[conversationKey(profile.name, name)];
+    await saveConversationConfiguration(config);
+}
+export function conversationSummary(conversation) {
+    const updated = new Date(conversation.updatedAt * 1000).toISOString();
+    const response = conversation.previousResponseId ? ` response=${conversation.previousResponseId}` : "";
+    return `${conversation.name}\t${conversation.profile}\t${updated}${response}`;
+}

package/dist/engine/agent-engine.d.ts

@@ -0,0 +1,38 @@
+import type { AgentRunOptions } from "../agent.js";
+import type { WorkbenchAuthController } from "../workbench/auth-controller.js";
+import { type WorkbenchCommandController } from "../workbench/command-controller.js";
+import { type WorkbenchSession } from "../workbench/session.js";
+import type { WorkbenchLifecycleEffect } from "../workbench/lifecycle-controller.js";
+import type { WorkbenchAction, WorkbenchState } from "../workbench/state.js";
+import type { AgentEngineServices } from "./services.js";
+export interface AgentEngineApp {
+    session: WorkbenchSession;
+    commands: WorkbenchCommandController;
+    snapshot(): WorkbenchState;
+    subscribe(listener: () => void): () => void;
+    dispatch(action: WorkbenchAction): void;
+    maybeCheckForUpdate(options?: AgentEngineLifecycleOptions): Promise<void>;
+    loadInitialSettings(options?: AgentEngineLifecycleOptions): Promise<void>;
+    loadWorkdir(path?: string, options?: AgentEngineLifecycleOptions): Promise<void>;
+    refreshAuth(profile?: string, options?: AgentEngineLifecycleOptions): Promise<void>;
+    abortActiveTurn(message?: string): Promise<void>;
+    startInitialPrompt(): Promise<void>;
+    submit(input: string): Promise<void>;
+    runLifecycleEffects(effects: WorkbenchLifecycleEffect[], options?: AgentEngineLifecycleOptions): void;
+    dispose(): void;
+}
+export interface AgentEngineAppOptions {
+    authController: WorkbenchAuthController;
+    baseOptions: AgentRunOptions;
+    profileName: string;
+    services?: Omit<AgentEngineServices, "auth">;
+    onDeleteProfile(): Promise<void>;
+    onExit(): void;
+    onLogin(): void;
+    onLogout(): void;
+    onSwitchProfile(name?: string): void;
+}
+export interface AgentEngineLifecycleOptions {
+    isMounted?: () => boolean;
+}
+export declare function createAgentEngine(options: AgentEngineAppOptions): AgentEngineApp;

package/dist/engine/agent-engine.js

@@ -0,0 +1,146 @@
+import { createWorkbenchCommandController, } from "../workbench/command-controller.js";
+import { createWorkbenchSession, } from "../workbench/session.js";
+export function createAgentEngine(options) {
+    const session = createWorkbenchSession({
+        authController: options.authController,
+        baseOptions: options.baseOptions,
+        services: options.services,
+    });
+    const commands = createWorkbenchCommandController({
+        authController: options.authController,
+        conversationController: session.conversation,
+        engine: session.engine,
+        localController: session.local,
+        options: options.baseOptions,
+        profileName: options.profileName,
+        settingsController: session.settings,
+        turnController: session.turn,
+        onDeleteProfile: options.onDeleteProfile,
+        onExit: options.onExit,
+        onLogin: options.onLogin,
+        onLogout: options.onLogout,
+        onSwitchProfile: options.onSwitchProfile,
+    });
+    async function submit(input) {
+        const submission = session.engine.submit(input);
+        if (submission.kind === "command") {
+            await commands.run(submission.command);
+            return;
+        }
+        if (submission.kind === "prompt") {
+            await session.turn.startPrompt(submission.prompt);
+        }
+    }
+    async function maybeCheckForUpdate(lifecycleOptions) {
+        const effects = await session.lifecycle.maybeCheckForUpdate();
+        runLifecycleEffects(effects, lifecycleOptions);
+    }
+    async function loadInitialSettings(lifecycleOptions = {}) {
+        try {
+            const settings = await session.settings.loadInitial({
+                modelExplicit: options.baseOptions.modelExplicit,
+                preset: options.baseOptions.preset,
+                presetExplicit: options.baseOptions.presetExplicit,
+            });
+            if (lifecycleOptions.isMounted && !lifecycleOptions.isMounted())
+                return;
+            session.engine.dispatch({ type: "settings.set", settings });
+            if (settings.activity) {
+                session.engine.dispatch({ type: "activity.add", level: "success", text: settings.activity });
+            }
+            if (settings.notice) {
+                session.engine.dispatch({ type: "message.add", role: "system", text: settings.notice });
+                session.engine.dispatch({ type: "activity.add", level: "warning", text: "Shell isolation setup is not configured" });
+            }
+            if (settings.warning) {
+                session.engine.dispatch({ type: "activity.add", level: "warning", text: settings.warning });
+            }
+        }
+        catch (error) {
+            if (lifecycleOptions.isMounted && !lifecycleOptions.isMounted())
+                return;
+            session.engine.dispatch({
+                type: "activity.add",
+                level: "warning",
+                text: `Config preferences unavailable: ${userFacingError(error)}`,
+            });
+        }
+    }
+    async function loadWorkdir(path, lifecycleOptions = {}) {
+        session.engine.dispatch({ type: "activity.add", text: "Loading workdir" });
+        try {
+            const workdir = await session.local.load(path);
+            if (lifecycleOptions.isMounted && !lifecycleOptions.isMounted())
+                return;
+            session.engine.dispatch({
+                type: "workdir.set",
+                workdir,
+            });
+        }
+        catch (error) {
+            if (lifecycleOptions.isMounted && !lifecycleOptions.isMounted())
+                return;
+            session.engine.dispatch({
+                type: "activity.add",
+                level: "error",
+                text: `Workdir unavailable: ${userFacingError(error)}`,
+            });
+        }
+    }
+    async function refreshAuth(profile, lifecycleOptions) {
+        const effects = await session.lifecycle.refreshAuth(profile);
+        runLifecycleEffects(effects, lifecycleOptions);
+    }
+    async function abortActiveTurn(message = "Abort requested.") {
+        await session.turn.abort(message);
+    }
+    async function startInitialPrompt() {
+        const state = session.engine.snapshot();
+        const initialPrompt = session.lifecycle.initialPrompt({
+            busy: state.busy,
+            promptParts: options.baseOptions.promptParts,
+            requiresWorkdir: state.contextEnabled,
+            workdir: state.workdir,
+        });
+        if (initialPrompt)
+            await session.turn.startPrompt(initialPrompt);
+    }
+    function runLifecycleEffects(effects, lifecycleOptions = {}) {
+        for (const effect of effects) {
+            switch (effect.type) {
+                case "dispatch":
+                    session.engine.dispatch(effect.action);
+                    break;
+                case "close":
+                    setTimeout(() => {
+                        if (lifecycleOptions.isMounted?.() ?? true)
+                            options.onExit();
+                    }, effect.delayMs);
+                    break;
+            }
+        }
+    }
+    return {
+        session,
+        commands,
+        snapshot: session.engine.snapshot,
+        subscribe: session.engine.subscribe,
+        dispatch: session.engine.dispatch,
+        maybeCheckForUpdate,
+        loadInitialSettings,
+        loadWorkdir,
+        refreshAuth,
+        abortActiveTurn,
+        startInitialPrompt,
+        submit,
+        runLifecycleEffects,
+        dispose() {
+            session.runtime.dispose();
+        },
+    };
+}
+function userFacingError(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}

package/dist/engine/index.d.ts

@@ -0,0 +1,50 @@
+export type { AgentEngineApp, AgentEngineAppOptions, AgentEngineLifecycleOptions, } from "./agent-engine.js";
+export { createAgentEngine, } from "./agent-engine.js";
+export type { AgentRunOptions, AgentTurnEvent, LocalToolApprovalRequest, WorkdirAccessMode, } from "../agent.js";
+export { agentResponseFailureMessage, agentTurnEventFromStreamEvent, clearPresetToolCatalogCache, conversationSummary, deleteConversation, getConversation, isAvailablePreset, listAvailablePresets, listConversations, resumeAgentAfterLocalApproval, runAgent, resolveAgentRequestTools, runAgentTurn, } from "../agent.js";
+export type { ChatOptions } from "../chat-options.js";
+export { normalizeChatOptions } from "../chat-options.js";
+export type { AgentEngineServices } from "./services.js";
+export { defaultBaseURL } from "../config.js";
+export type { AuthProfile, ConversationState, Profile, WorkbenchPreferences, } from "../config.js";
+export { activeProfile, loadAppConfiguration, loadConfig, loadConversationConfiguration, loadWorkbenchPreferences, redactSecret, saveAppConfiguration, saveConfig, saveConversationConfiguration, updateWorkbenchPreferences, } from "../config.js";
+export type { AuthStatus, RuntimeProfile, } from "../profile.js";
+export { AuthSessionExpiredError, browserAccessTokenExpiresWithin, deleteProfile, formatDeviceUserCode, getAuthStatus, listProfiles, loginWithAPIKey, loginWithBrowser, openBrowserURL, profileSummary, refreshActiveProfileIfNeeded, refreshBrowserSession, refreshIfNeeded, resolveRuntimeProfile, saveBrowserProfile, startBrowserAuthChallenge, useProfile, waitForBrowserAuthChallenge, } from "../profile.js";
+export { appVersion, configureAgentAppRuntime, currentAgentAppRuntime, defaultAppAuthor, defaultAppName, defaultAppVersion, ensureRuntime, runtime, } from "../runtime/index.js";
+export type { AgentAppRuntimeContext, AgentAppRuntimeOptions, } from "../runtime/index.js";
+export { checkForUpdate, compareVersions, formatUpdateNotice, } from "../update.js";
+export type { WorkdirContextOptions, WorkdirOptions, WorkdirService, } from "../workdir/index.js";
+export { buildWorkdirContextBlock, openWorkdir, } from "../workdir/index.js";
+export type { WorkbenchAuthController } from "../workbench/auth-controller.js";
+export { authStatusText, createWorkbenchAuthController, } from "../workbench/auth-controller.js";
+export type { AuthGateState, WorkbenchAuthGateController, } from "../workbench/auth-gate-controller.js";
+export { authMethods, createWorkbenchAuthGateController, } from "../workbench/auth-gate-controller.js";
+export type { WorkbenchCommandController } from "../workbench/command-controller.js";
+export { createWorkbenchCommandController } from "../workbench/command-controller.js";
+export type { WorkbenchConversationController } from "../workbench/conversation-controller.js";
+export { createConversationName, createWorkbenchConversationController, defaultTranscriptExportPath, } from "../workbench/conversation-controller.js";
+export type { WorkbenchEngine, WorkbenchSubmission, } from "../workbench/engine.js";
+export { createWorkbenchEngine } from "../workbench/engine.js";
+export type { WorkbenchInputController } from "../workbench/input-controller.js";
+export { createWorkbenchInputController } from "../workbench/input-controller.js";
+export type { IsolatorInstallConfig, IsolatorInstallOptions, IsolatorInstallResult, } from "../workbench/isolator-installer.js";
+export { defaultIsolatorInstallPath, ensureConfiguredIsolator, installConfiguredIsolator, normalizeInstallPath, normalizeSourceURL, relocateInstalledIsolator, validateInstalledIsolator, } from "../workbench/isolator-installer.js";
+export type { WorkbenchLifecycleController, WorkbenchLifecycleEffect, } from "../workbench/lifecycle-controller.js";
+export { createWorkbenchLifecycleController, updateNoticeEffects, } from "../workbench/lifecycle-controller.js";
+export type { WorkbenchLocalController } from "../workbench/local-controller.js";
+export { createWorkbenchLocalController } from "../workbench/local-controller.js";
+export type { WorkbenchRenderModel } from "../workbench/render-model.js";
+export { buildWorkbenchRenderModel, busySpinner, pendingLocalLabel, } from "../workbench/render-model.js";
+export type { WorkbenchRuntimeController } from "../workbench/runtime-controller.js";
+export { createWorkbenchRuntimeController } from "../workbench/runtime-controller.js";
+export type { WorkbenchSession, WorkbenchSessionOptions, } from "../workbench/session.js";
+export { createWorkbenchSession, sessionState, } from "../workbench/session.js";
+export type { WorkbenchSettingsController, WorkbenchSettingsSnapshot, } from "../workbench/settings-controller.js";
+export { createWorkbenchSettingsController, formatPresetList, UnknownPresetError, } from "../workbench/settings-controller.js";
+export type { ShellIsolationMode, ShellIsolationPreferences, } from "../workbench/shell-isolation.js";
+export { localShellIsolationOptions } from "../workbench/shell-isolation.js";
+export type { WorkbenchTurnController } from "../workbench/turn-controller.js";
+export { createWorkbenchTurnController } from "../workbench/turn-controller.js";
+export { buildTranscriptLines, buildTranscriptViewModel, elapsedDots, spinnerGlyph, } from "../workbench/view-model.js";
+export type { ActivityLevel, InputHistory, LocalToolApproval, RenderMode, WorkbenchAction, WorkbenchActivity, WorkbenchCommand, WorkbenchMessage, WorkbenchRole, WorkbenchState, WorkbenchWorkdirStatus, } from "../workbench/state.js";
+export { activityColor, createInitialWorkbenchState, createInputHistory, formatTranscript, formatTranscriptPreview, helpText, parsePendingApprovalCommand, parseWorkbenchCommand, workbenchReducer, workdirText, } from "../workbench/state.js";

package/dist/engine/index.js

@@ -0,0 +1,26 @@
+export { createAgentEngine, } from "./agent-engine.js";
+export { agentResponseFailureMessage, agentTurnEventFromStreamEvent, clearPresetToolCatalogCache, conversationSummary, deleteConversation, getConversation, isAvailablePreset, listAvailablePresets, listConversations, resumeAgentAfterLocalApproval, runAgent, resolveAgentRequestTools, runAgentTurn, } from "../agent.js";
+export { normalizeChatOptions } from "../chat-options.js";
+export { defaultBaseURL } from "../config.js";
+export { activeProfile, loadAppConfiguration, loadConfig, loadConversationConfiguration, loadWorkbenchPreferences, redactSecret, saveAppConfiguration, saveConfig, saveConversationConfiguration, updateWorkbenchPreferences, } from "../config.js";
+export { AuthSessionExpiredError, browserAccessTokenExpiresWithin, deleteProfile, formatDeviceUserCode, getAuthStatus, listProfiles, loginWithAPIKey, loginWithBrowser, openBrowserURL, profileSummary, refreshActiveProfileIfNeeded, refreshBrowserSession, refreshIfNeeded, resolveRuntimeProfile, saveBrowserProfile, startBrowserAuthChallenge, useProfile, waitForBrowserAuthChallenge, } from "../profile.js";
+export { appVersion, configureAgentAppRuntime, currentAgentAppRuntime, defaultAppAuthor, defaultAppName, defaultAppVersion, ensureRuntime, runtime, } from "../runtime/index.js";
+export { checkForUpdate, compareVersions, formatUpdateNotice, } from "../update.js";
+export { buildWorkdirContextBlock, openWorkdir, } from "../workdir/index.js";
+export { authStatusText, createWorkbenchAuthController, } from "../workbench/auth-controller.js";
+export { authMethods, createWorkbenchAuthGateController, } from "../workbench/auth-gate-controller.js";
+export { createWorkbenchCommandController } from "../workbench/command-controller.js";
+export { createConversationName, createWorkbenchConversationController, defaultTranscriptExportPath, } from "../workbench/conversation-controller.js";
+export { createWorkbenchEngine } from "../workbench/engine.js";
+export { createWorkbenchInputController } from "../workbench/input-controller.js";
+export { defaultIsolatorInstallPath, ensureConfiguredIsolator, installConfiguredIsolator, normalizeInstallPath, normalizeSourceURL, relocateInstalledIsolator, validateInstalledIsolator, } from "../workbench/isolator-installer.js";
+export { createWorkbenchLifecycleController, updateNoticeEffects, } from "../workbench/lifecycle-controller.js";
+export { createWorkbenchLocalController } from "../workbench/local-controller.js";
+export { buildWorkbenchRenderModel, busySpinner, pendingLocalLabel, } from "../workbench/render-model.js";
+export { createWorkbenchRuntimeController } from "../workbench/runtime-controller.js";
+export { createWorkbenchSession, sessionState, } from "../workbench/session.js";
+export { createWorkbenchSettingsController, formatPresetList, UnknownPresetError, } from "../workbench/settings-controller.js";
+export { localShellIsolationOptions } from "../workbench/shell-isolation.js";
+export { createWorkbenchTurnController } from "../workbench/turn-controller.js";
+export { buildTranscriptLines, buildTranscriptViewModel, elapsedDots, spinnerGlyph, } from "../workbench/view-model.js";
+export { activityColor, createInitialWorkbenchState, createInputHistory, formatTranscript, formatTranscriptPreview, helpText, parsePendingApprovalCommand, parseWorkbenchCommand, workbenchReducer, workdirText, } from "../workbench/state.js";

package/dist/engine/services.d.ts

@@ -0,0 +1,20 @@
+import type { WorkbenchAuthController } from "../workbench/auth-controller.js";
+import type { WorkbenchConversationController } from "../workbench/conversation-controller.js";
+import type { WorkbenchEngine } from "../workbench/engine.js";
+import type { WorkbenchInputController } from "../workbench/input-controller.js";
+import type { WorkbenchLifecycleController } from "../workbench/lifecycle-controller.js";
+import type { WorkbenchLocalController } from "../workbench/local-controller.js";
+import type { WorkbenchRuntimeController } from "../workbench/runtime-controller.js";
+import type { WorkbenchSettingsController } from "../workbench/settings-controller.js";
+import type { WorkbenchTurnController } from "../workbench/turn-controller.js";
+export interface AgentEngineServices {
+    auth?: WorkbenchAuthController;
+    conversation?: WorkbenchConversationController;
+    engine?: WorkbenchEngine;
+    input?: WorkbenchInputController;
+    lifecycle?: WorkbenchLifecycleController;
+    local?: WorkbenchLocalController;
+    runtime?: WorkbenchRuntimeController;
+    settings?: WorkbenchSettingsController;
+    turn?: WorkbenchTurnController;
+}