@agent-api/cli 0.2.0 → 0.3.0

package/dist/agent/runner.js

@@ -1,486 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { functionCallOutputInput, pendingFunctionCalls, resolvePresetTools, resolvePresetToolsFromCatalog, } from "@agent-api/sdk";
-import { createLocalShellToolRegistry, createLocalWorkdirToolRegistry, localShellToolInstructions, localWorkdirToolInstructions, } from "@agent-api/sdk/local";
-import { resolvePreviousResponseID, updateConversation } from "../conversation/index.js";
-import { resolveRuntimeProfile } from "../profile.js";
-import { buildWorkdirContextBlock, openWorkdir } from "../workdir/index.js";
-import { localShellIsolationOptions } from "../workbench/shell-isolation.js";
-const defaultCatalogCacheTTLMS = 10 * 60_000;
-const presetCatalogCache = new Map();
-const toolCatalogCache = new Map();
-export async function runAgent(options) {
-    const result = await runAgentTurn(options, (event) => {
-        if (event.type === "text.delta")
-            process.stdout.write(event.delta);
-    });
-    if (result.text && options.stream === false) {
-        console.log(result.text);
-    }
-    else if (options.stream !== false) {
-        process.stdout.write("\n");
-    }
-}
-export async function runAgentTurn(options, onEvent) {
-    const runtimeProfile = await resolveRuntimeProfile(options.profile);
-    const localWorkdir = await prepareLocalWorkdirTools(options);
-    const input = await buildInput(options);
-    const previousResponseId = await resolvePreviousResponseID(options);
-    const tools = await resolveAgentRequestTools(runtimeProfile.client, options.preset, localWorkdir?.registry.definitions(), { baseURL: runtimeProfile.profile.baseURL });
-    const params = {
-        input,
-        instructions: localWorkdir?.instructions,
-        tools,
-        preset: options.preset,
-        model: options.model,
-        previous_response_id: previousResponseId,
-        stream: options.stream ?? true,
-    };
-    if (localWorkdir) {
-        return await runAgentTurnWithLocalTools(runtimeProfile.client.agent, runtimeProfile.client.responses, params, options, localWorkdir.registry, onEvent);
-    }
-    if (params.stream) {
-        const stream = await runtimeProfile.client.agent.create({ ...params, stream: true }, requestAbortOptions(options.abortSignal));
-        let finalResponseID = "";
-        let text = "";
-        for await (const event of stream) {
-            throwIfAborted(options.abortSignal);
-            emitAgentTurnEvent(event, onEvent);
-            if (event.type === "response.output_text.delta" && event.delta) {
-                text += event.delta;
-            }
-            if (event.response?.id) {
-                finalResponseID = event.response.id;
-            }
-            if (event.type === "response.failed") {
-                const message = event.error?.message || "agent run failed";
-                throw new Error(message);
-            }
-        }
-        if (finalResponseID) {
-            await updateConversation(options, finalResponseID);
-        }
-        return { text, responseID: finalResponseID || undefined };
-    }
-    const response = await runtimeProfile.client.agent.create({ ...params, stream: false }, requestAbortOptions(options.abortSignal));
-    await updateConversation(options, response.id);
-    return { text: response.output_text || "", responseID: response.id };
-}
-export async function resumeAgentAfterLocalApproval(options, approval, output, onEvent) {
-    const runtimeProfile = await resolveRuntimeProfile(options.profile);
-    const localWorkdir = await prepareLocalWorkdirTools(options);
-    if (!localWorkdir) {
-        throw new Error("local tools are not available for approval continuation");
-    }
-    const tools = await resolveAgentRequestTools(runtimeProfile.client, options.preset, localWorkdir.registry.definitions(), { baseURL: runtimeProfile.profile.baseURL });
-    return await runAgentTurnWithLocalTools(runtimeProfile.client.agent, runtimeProfile.client.responses, {
-        input: [functionCallOutputInput(approval.callID, output)],
-        instructions: localWorkdir.instructions,
-        tools,
-        preset: options.preset,
-        model: options.model,
-        previous_response_id: approval.responseID,
-        stream: options.stream ?? true,
-    }, options, localWorkdir.registry, onEvent);
-}
-export async function listAvailablePresets(profileName) {
-    const runtimeProfile = await resolveRuntimeProfile(profileName);
-    const presets = await cachedPresetCatalog(runtimeProfile.profile.baseURL, defaultCatalogCacheTTLMS, () => runtimeProfile.client.presets.list());
-    return presets.data
-        .map((preset) => {
-        const item = preset;
-        const name = typeof item.preset === "string"
-            ? item.preset
-            : typeof item.name === "string"
-                ? item.name
-                : "";
-        return {
-            preset: name,
-            description: typeof item.description === "string" ? item.description : undefined,
-        };
-    })
-        .filter((preset) => preset.preset.length > 0)
-        .sort((a, b) => a.preset.localeCompare(b.preset));
-}
-export async function isAvailablePreset(profileName, preset) {
-    const available = await listAvailablePresets(profileName);
-    return available.some((item) => item.preset === preset);
-}
-async function runAgentTurnWithLocalTools(agent, responses, initialParams, options, registry, onEvent) {
-    let input = initialParams.input;
-    let previousResponseID = initialParams.previous_response_id;
-    let finalResponse;
-    const maxLocalToolRounds = 8;
-    for (let round = 0; round <= maxLocalToolRounds; round += 1) {
-        throwIfAborted(options.abortSignal);
-        const response = await createAgentResponseWithOptionalStream(agent, {
-            input,
-            instructions: initialParams.instructions,
-            tools: initialParams.tools,
-            preset: initialParams.preset,
-            model: initialParams.model,
-            previous_response_id: previousResponseID,
-            stream: initialParams.stream,
-        }, responses, options.abortSignal, onEvent);
-        throwIfAborted(options.abortSignal);
-        finalResponse = response;
-        if (initialParams.stream === false) {
-            onEvent?.({ type: "response.started", responseID: response.id });
-        }
-        if (response.status === "failed") {
-            const message = agentResponseFailureMessage(response);
-            onEvent?.({ type: "response.failed", message });
-            throw new Error(message);
-        }
-        const pending = pendingFunctionCalls(response);
-        if (pending.length === 0) {
-            if (initialParams.stream === false) {
-                onEvent?.({ type: "response.completed", responseID: response.id });
-            }
-            await updateConversation(options, response.id);
-            return { text: response.output_text || "", responseID: response.id };
-        }
-        const localResult = await executeLocalFunctionCalls(response, registry, options.abortSignal, onEvent);
-        if (localResult.approvalRequested) {
-            const message = localApprovalMessage(localResult.approvalRequested);
-            if (initialParams.stream !== false) {
-                onEvent?.({ type: "text.delta", delta: message });
-            }
-            if (initialParams.stream === false) {
-                onEvent?.({ type: "response.completed", responseID: response.id });
-            }
-            await updateConversation(options, response.id);
-            return {
-                text: message,
-                responseID: response.id,
-            };
-        }
-        const outputs = localResult.outputs;
-        input = outputs;
-        previousResponseID = response.id;
-    }
-    throw new Error(`local function loop exceeded ${maxLocalToolRounds} rounds after ${finalResponse?.id || "initial response"}`);
-}
-async function createAgentResponseWithOptionalStream(agent, params, responses, abortSignal, onEvent) {
-    throwIfAborted(abortSignal);
-    if (!params.stream) {
-        const response = await agent.create({ ...params, stream: false }, requestAbortOptions(abortSignal));
-        throwIfAborted(abortSignal);
-        return response;
-    }
-    const stream = await agent.create({ ...params, stream: true }, requestAbortOptions(abortSignal));
-    let finalResponse;
-    let responseID = "";
-    let sawTextDelta = false;
-    for await (const event of stream) {
-        throwIfAborted(abortSignal);
-        emitAgentTurnEvent(event, onEvent);
-        if (event.type === "response.output_text.delta") {
-            sawTextDelta = true;
-        }
-        if (event.response?.id) {
-            responseID = event.response.id;
-        }
-        if (event.type === "response.completed" && event.response) {
-            finalResponse = withOutputText(event.response);
-        }
-        if (event.type === "response.failed") {
-            throw new Error(event.error?.message || "agent run failed");
-        }
-    }
-    throwIfAborted(abortSignal);
-    if (!finalResponse && responseID) {
-        finalResponse = await responses.retrieve(responseID, requestAbortOptions(abortSignal));
-    }
-    if (!finalResponse) {
-        throw new Error("agent stream completed without a final response");
-    }
-    if (!sawTextDelta && finalResponse.output_text) {
-        onEvent?.({ type: "text.delta", delta: finalResponse.output_text });
-    }
-    return finalResponse;
-}
-export function agentResponseFailureMessage(response) {
-    const details = [];
-    if (response.id)
-        details.push(response.id);
-    if (response.model)
-        details.push(`model=${response.model}`);
-    const label = details.length > 0 ? `Agent response ${details.join(" ")}` : "Agent response";
-    const message = response.error?.message || "agent run failed";
-    const code = response.error?.code || response.error?.type;
-    return code ? `${label} failed: ${message} (${code})` : `${label} failed: ${message}`;
-}
-function withOutputText(response) {
-    if (response.output_text !== undefined) {
-        return response;
-    }
-    const outputText = response.output
-        .filter((item) => item.type === "message")
-        .flatMap((item) => item.content)
-        .filter((part) => part.type === "output_text" && typeof part.text === "string")
-        .map((part) => part.text)
-        .join("");
-    return { ...response, output_text: outputText };
-}
-export function agentTurnEventFromStreamEvent(event) {
-    const responseID = event.response?.id;
-    switch (event.type) {
-        case "response.created":
-        case "response.in_progress":
-            return { type: "response.started", responseID };
-        case "response.output_text.delta":
-            return event.delta ? { type: "text.delta", delta: event.delta } : null;
-        case "response.completed":
-            return { type: "response.completed", responseID };
-        case "response.failed":
-            return { type: "response.failed", message: event.error?.message || "agent run failed" };
-        case "response.reasoning.started":
-            return { type: "reasoning.started" };
-        case "response.reasoning.stopped":
-            return { type: "reasoning.stopped", thought: event.thought };
-        case "response.reasoning.search_queries":
-            return { type: "reasoning.search_queries", queries: event.queries ?? [] };
-        case "response.reasoning.search_results":
-            return { type: "reasoning.search_results", count: event.results?.length ?? 0 };
-        case "response.reasoning.fetch_url_queries":
-            return { type: "reasoning.fetch_url_queries", urls: event.urls ?? [] };
-        case "response.reasoning.fetch_url_results":
-            return { type: "reasoning.fetch_url_results", count: event.contents?.length ?? 0 };
-        case "response.tool.invocation.completed":
-            return {
-                type: "tool.completed",
-                name: event.tool_result?.tool_name || "tool",
-                status: event.tool_result?.status,
-            };
-        case "response.model.requested":
-            return {
-                type: "model.requested",
-                model: event.model_call?.model,
-                provider: event.model_call?.provider,
-            };
-        case "response.model.completed":
-            return {
-                type: "model.completed",
-                model: event.model_call?.model,
-                provider: event.model_call?.provider,
-            };
-        case "response.model.failed":
-            return {
-                type: "model.failed",
-                model: event.model_call?.model,
-                provider: event.model_call?.provider,
-            };
-        case "response.step.completed":
-            return { type: "step.completed", stepType: event.step?.step_type };
-        case "response.step.failed":
-            return { type: "step.failed", stepType: event.step?.step_type };
-        default:
-            return { type: "raw", eventType: event.type };
-    }
-}
-function emitAgentTurnEvent(event, onEvent) {
-    if (!onEvent)
-        return;
-    const mapped = agentTurnEventFromStreamEvent(event);
-    if (mapped)
-        onEvent(mapped);
-}
-export async function resolveAgentRequestTools(client, preset, tools, options = {}) {
-    if (!tools || tools.length === 0) {
-        return undefined;
-    }
-    if (!preset) {
-        return [...tools];
-    }
-    if (options.baseURL) {
-        const ttl = options.cacheTTLMS ?? defaultCatalogCacheTTLMS;
-        const [presets, toolCatalog] = await Promise.all([
-            cachedPresetCatalog(options.baseURL, ttl, () => client.presets.list()),
-            cachedToolCatalog(options.baseURL, ttl, () => client.tools.list()),
-        ]);
-        const resolved = resolvePresetToolsFromCatalog({
-            preset,
-            tools,
-            presets: presets.data,
-            toolCatalog: toolCatalog.data,
-        });
-        return resolved.tools;
-    }
-    const resolved = await resolvePresetTools(client, { preset, tools });
-    return resolved.tools;
-}
-export function clearPresetToolCatalogCache(baseURL) {
-    if (!baseURL) {
-        presetCatalogCache.clear();
-        toolCatalogCache.clear();
-        return;
-    }
-    const key = catalogCacheKey(baseURL);
-    presetCatalogCache.delete(key);
-    toolCatalogCache.delete(key);
-}
-async function cachedPresetCatalog(baseURL, ttl, load) {
-    return cachedCatalog(presetCatalogCache, baseURL, ttl, load);
-}
-async function cachedToolCatalog(baseURL, ttl, load) {
-    return cachedCatalog(toolCatalogCache, baseURL, ttl, load);
-}
-async function cachedCatalog(cache, baseURL, ttl, load) {
-    const key = catalogCacheKey(baseURL);
-    const now = Date.now();
-    const existing = cache.get(key);
-    if (existing && existing.expiresAt > now) {
-        return existing.promise;
-    }
-    const promise = load().catch((error) => {
-        if (cache.get(key)?.promise === promise) {
-            cache.delete(key);
-        }
-        throw error;
-    });
-    cache.set(key, { expiresAt: now + Math.max(0, ttl), promise });
-    return promise;
-}
-function catalogCacheKey(baseURL) {
-    return baseURL.trim().replace(/\/+$/, "");
-}
-async function buildInput(options) {
-    const chunks = [];
-    if (options.promptParts.length > 0) {
-        chunks.push(options.promptParts.join(" "));
-    }
-    if (options.file) {
-        chunks.push(await readFile(options.file, "utf8"));
-    }
-    if (options.stdin || chunks.length === 0) {
-        const piped = await readStdinIfAvailable();
-        if (piped.trim())
-            chunks.push(piped);
-    }
-    if (chunks.length === 0) {
-        throw new Error("Prompt is required. Pass text, --file, or pipe stdin.");
-    }
-    if (shouldUseLocalTools(options)) {
-        chunks.push("Local operations are available through the `local_workdir` and `local_shell` function tools. Use `local_workdir` for local file inspection and edits. Use `local_shell` for commands, tests, builds, package managers, and git. Do not encode local edits or commands in the final answer when a tool call is needed.");
-        chunks.push(await buildWorkdirContextBlock({
-            path: options.workdir || process.cwd(),
-            query: options.contextQuery,
-            maxFiles: options.maxContextFiles,
-            maxBytes: options.maxContextBytes,
-        }));
-    }
-    return chunks.join("\n\n");
-}
-async function prepareLocalWorkdirTools(options) {
-    if (!shouldUseLocalTools(options)) {
-        return null;
-    }
-    const service = await openWorkdir({ path: options.workdir || process.cwd() });
-    const registry = createLocalWorkdirToolRegistry(service.workdir, {
-        accessMode: localToolAccessMode(options),
-    });
-    const shellRegistry = createLocalShellToolRegistry({
-        accessMode: localToolAccessMode(options),
-        workdir: service.workdir,
-        ...localShellIsolationOptions(options.shellIsolation),
-    });
-    return {
-        registry: combineLocalToolRegistries(registry, shellRegistry),
-        instructions: [
-            localWorkdirToolInstructions(),
-            localShellToolInstructions({
-                accessMode: localToolAccessMode(options),
-                cwd: service.workdir.root,
-                ...localShellIsolationOptions(options.shellIsolation),
-            }),
-            "Use local_workdir for selected local workdir operations. Prefer summarize/list/search/grep before read/read_lines. Prefer preview_edits/apply_edits for source edits. Use local_shell for command/process tasks. In approval mode, local actions return requires_approval and must be explained to the user instead of retried blindly.",
-        ].join("\n\n"),
-    };
-}
-function shouldUseLocalTools(options) {
-    if (options.accessMode === "off")
-        return false;
-    return Boolean(options.includeLocalContext || options.workdir || options.accessMode === "approval" || options.accessMode === "full");
-}
-function localToolAccessMode(options) {
-    return options.accessMode === "full" ? "full" : "approval";
-}
-function combineLocalToolRegistries(workdir, shell) {
-    return {
-        definitions: () => [
-            ...workdir.definitions(),
-            ...shell.definitions(),
-        ],
-        execute: async (name, args, abortSignal) => {
-            if (name === workdir.toolName)
-                return await workdir.execute(name, args);
-            if (name === shell.toolName)
-                return await shell.execute(name, args, { signal: abortSignal });
-            throw new Error(`no local handler registered for function ${name}`);
-        },
-        has: (name) => name === workdir.toolName || name === shell.toolName,
-    };
-}
-async function executeLocalFunctionCalls(response, registry, abortSignal, onEvent) {
-    const outputs = [];
-    for (const call of pendingFunctionCalls(response)) {
-        throwIfAborted(abortSignal);
-        if (!registry.has(call.name)) {
-            throw new Error(`no local handler registered for function ${call.name}`);
-        }
-        const args = call.arguments ? JSON.parse(call.arguments) : {};
-        const result = await registry.execute(call.name, args, abortSignal);
-        throwIfAborted(abortSignal);
-        const action = typeof result.action === "string"
-            ? result.action
-            : typeof args.action === "string"
-                ? args.action
-                : undefined;
-        if (result.requires_approval === true) {
-            const approvalRequested = {
-                name: call.name,
-                action,
-                arguments: args,
-                preview: result.preview,
-                callID: call.call_id,
-                responseID: response.id,
-            };
-            onEvent?.({
-                type: "local_tool.approval_requested",
-                ...approvalRequested,
-            });
-            return { outputs, approvalRequested };
-        }
-        outputs.push(functionCallOutputInput(call.call_id, result));
-        onEvent?.({
-            type: "local_tool.completed",
-            name: call.name,
-            action,
-            requiresApproval: false,
-        });
-    }
-    return { outputs };
-}
-function throwIfAborted(signal) {
-    if (!signal?.aborted)
-        return;
-    throw new Error("Agent turn aborted.");
-}
-function requestAbortOptions(signal) {
-    return signal ? { signal } : undefined;
-}
-function localApprovalMessage(approval) {
-    return [
-        `Local action requires approval: ${approval.name}${approval.action ? `.${approval.action}` : ""}.`,
-        "Review it in the workbench, then use /apply to execute it or /reject to discard it.",
-    ].join("\n");
-}
-async function readStdinIfAvailable() {
-    if (process.stdin.isTTY)
-        return "";
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    }
-    return Buffer.concat(chunks).toString("utf8");
-}

package/dist/agent.d.ts

@@ -1,2 +0,0 @@
-export { type AgentRunOptions, type AgentTurnEvent, type AgentTurnResult, type LocalToolApprovalRequest, type WorkdirAccessMode, agentResponseFailureMessage, agentTurnEventFromStreamEvent, clearPresetToolCatalogCache, isAvailablePreset, listAvailablePresets, resolveAgentRequestTools, resumeAgentAfterLocalApproval, runAgent, runAgentTurn, } from "./agent/runner.js";
-export { conversationSummary, deleteConversation, getConversation, listConversations, } from "./conversation/index.js";

package/dist/agent.js

@@ -1,2 +0,0 @@
-export { agentResponseFailureMessage, agentTurnEventFromStreamEvent, clearPresetToolCatalogCache, isAvailablePreset, listAvailablePresets, resolveAgentRequestTools, resumeAgentAfterLocalApproval, runAgent, runAgentTurn, } from "./agent/runner.js";
-export { conversationSummary, deleteConversation, getConversation, listConversations, } from "./conversation/index.js";

package/dist/chat-options.d.ts

@@ -1,37 +0,0 @@
-import type { WorkdirAccessMode } from "./agent.js";
-export type ChatOptions = {
-    profile?: string;
-    conversation?: string;
-    preset?: string;
-    model?: string;
-    file?: string;
-    stdin?: boolean;
-    workdir?: string;
-    localContext?: boolean;
-    contextQuery?: string;
-    maxContextFiles?: string;
-    maxContextBytes?: string;
-    access?: string;
-    restart?: boolean;
-    stream?: boolean;
-};
-export declare function normalizeChatOptions(promptParts: string[], options: ChatOptions): {
-    profile: string | undefined;
-    promptParts: string[];
-    file: string | undefined;
-    stdin: boolean | undefined;
-    preset: string | undefined;
-    presetExplicit: boolean;
-    model: string | undefined;
-    modelExplicit: boolean;
-    stream: boolean;
-    conversation: string;
-    continueConversation: boolean;
-    restartConversation: boolean | undefined;
-    workdir: string | undefined;
-    includeLocalContext: boolean | undefined;
-    contextQuery: string | undefined;
-    maxContextFiles: number | undefined;
-    maxContextBytes: number | undefined;
-    accessMode: WorkdirAccessMode | undefined;
-};

package/dist/chat-options.js

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

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