@best-agent/cli 0.0.2-beta.8 → 0.0.2-beta.9

package/dist/provider-model-limits.d.ts

@@ -1,8 +0,0 @@
-import { type IndexedProviderAdapter } from "./provider-model-limit-index.generated.js";
-export type { IndexedProviderAdapter };
-export interface ProviderModelLimit {
-    context?: number;
-    output?: number;
-}
-export declare function inferProviderModelLimit(modelId: string, adapter?: IndexedProviderAdapter, strategy?: "lowest" | "highest"): ProviderModelLimit | undefined;
-//# sourceMappingURL=provider-model-limits.d.ts.map

package/dist/provider-model-limits.js

@@ -1,43 +0,0 @@
-import { MODEL_LIMIT_INDEX, } from "./provider-model-limit-index.generated.js";
-export function inferProviderModelLimit(modelId, adapter, strategy = "highest") {
-    const normalizedModelId = modelId.trim().toLowerCase();
-    if (!normalizedModelId) {
-        return undefined;
-    }
-    const adapters = adapter ? [adapter] : Object.keys(MODEL_LIMIT_INDEX);
-    let bestContext;
-    let bestOutput;
-    for (const adapterId of adapters) {
-        const entry = MODEL_LIMIT_INDEX[adapterId]?.[normalizedModelId];
-        if (!entry) {
-            continue;
-        }
-        const [minContext, maxContext, minOutput, maxOutput] = entry;
-        const nextContext = strategy === "lowest" ? minContext : maxContext;
-        const nextOutput = strategy === "lowest" ? minOutput : maxOutput;
-        if (nextContext > 0) {
-            bestContext =
-                bestContext == null
-                    ? nextContext
-                    : strategy === "lowest"
-                        ? Math.min(bestContext, nextContext)
-                        : Math.max(bestContext, nextContext);
-        }
-        if (nextOutput > 0) {
-            bestOutput =
-                bestOutput == null
-                    ? nextOutput
-                    : strategy === "lowest"
-                        ? Math.min(bestOutput, nextOutput)
-                        : Math.max(bestOutput, nextOutput);
-        }
-    }
-    if (bestContext == null && bestOutput == null) {
-        return undefined;
-    }
-    return {
-        ...(bestContext != null ? { context: bestContext } : {}),
-        ...(bestOutput != null ? { output: bestOutput } : {}),
-    };
-}
-//# sourceMappingURL=provider-model-limits.js.map

package/dist/runtime.d.ts

@@ -1,47 +0,0 @@
-import { AgentRuntime, type ToolDefinition } from "@best-agent/engine";
-import { type ExtensionRegistry } from "@best-agent/extensions";
-import type { ProviderConfig } from "@best-agent/protocol";
-export { resolveCliStorageRoot } from "./cli-storage.js";
-export type CliPersistedState = Readonly<{
-    dimsdk?: {
-        providerState?: Record<string, unknown>;
-    };
-    providerConfig?: ProviderConfig;
-}>;
-export type CliRuntimeOptions = Readonly<{
-    approvalTimeoutMs?: number;
-    cwd?: string;
-    extensionsRoot?: string;
-    guardian?: {
-        enabled?: boolean;
-        model?: string;
-        threshold?: number;
-        timeoutMs?: number;
-    };
-    providerConfig?: ProviderConfig;
-    storageRoot?: string;
-}>;
-export declare function resolveCliReadableRoots(cwd?: string): string[];
-export declare function resolveCliAllowAllShell(): boolean;
-export declare function createCliRuntime(options: CliRuntimeOptions, injected?: Readonly<{
-    persistedState?: CliPersistedState;
-}>): Promise<AgentRuntime>;
-export declare function readCliPersistedState(storageRoot: string): CliPersistedState | undefined;
-export declare function writeCliPersistedState(storageRoot: string, state: CliPersistedState): void;
-export declare function hydrateDimSdkProviderSelection(state: {
-    config: {
-        model?: unknown;
-    };
-    provider: Record<string, unknown>;
-}, input: Readonly<{
-    persistedProviderState?: Record<string, unknown>;
-    providerConfig?: ProviderConfig;
-}>): void;
-export declare function resolveProviderConfigFromDimSdkState(state: Readonly<{
-    config?: {
-        model?: unknown;
-    };
-    provider?: Record<string, unknown>;
-}>, fallback?: ProviderConfig): ProviderConfig | undefined;
-export declare function loadMcpTools(registry: ExtensionRegistry): ToolDefinition[];
-//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.js

@@ -1,516 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { delimiter, dirname, join, resolve } from "node:path";
-import { AgentRuntime, DEFAULT_ALLOWED_TOOLS, LocalSandbox, createCommandToolDefinition, createDefaultRuntimePolicy, createDefaultToolRegistry, createMcpToolDefinition, } from "@best-agent/engine";
-import { loadExtensionRegistry, resolveInstalledExtensionSkills, } from "@best-agent/extensions";
-import { isRecord, markStartup, withStartupSpan, withStartupSpanAsync, } from "@best-agent/foundation";
-import { enrichProviderConfig, parseProviderCompatibilityMode, parseProviderDecisionTransportMode, parseProviderKind, } from "./provider-config-env.js";
-import { withPerfSpan, withPerfSpanAsync } from "./dimsdk/core/observability/perf-log.js";
-import { resolveCliStorageRoot } from "./cli-storage.js";
-export { resolveCliStorageRoot } from "./cli-storage.js";
-const PROVIDER_KIND_BY_DIMSDK_ID = {
-    aihubmix: "aihubmix",
-    "aihubmix-responses": "aihubmix-responses",
-    anthropic: "anthropic",
-    custom: "customProvider",
-    deepseek: "deepseek",
-    google: "google",
-    moonshot: "moonshotai",
-    "moonshot-ai": "moonshotai",
-    "dimcode-api-oauth": "customProvider",
-    "flymux-anthropic": "customProvider",
-    "flymux-openai": "customProvider",
-    "xiaomi-token-plan-ams": "customProvider",
-    "xiaomi-token-plan-cn": "customProvider",
-    "xiaomi-token-plan-sgp": "customProvider",
-    openai: "openai",
-    "openai-responses": "openai-responses",
-    xai: "xai",
-    "xai-responses": "xai-responses",
-    zenmux: "zenmux",
-};
-const DIMSDK_ID_BY_PROVIDER_KIND = {
-    aihubmix: "aihubmix",
-    "aihubmix-responses": "aihubmix-responses",
-    anthropic: "anthropic",
-    customProvider: "custom",
-    deepseek: "deepseek",
-    google: "google",
-    moonshotai: "moonshot-ai",
-    openai: "openai",
-    "openai-responses": "openai-responses",
-    xai: "xai",
-    "xai-responses": "xai-responses",
-    zenmux: "zenmux",
-};
-const DEFAULT_WEB_SEARCH_API_ENDPOINT = "https://google.serper.dev/search?format=json";
-const DEFAULT_WEB_SEARCH_NUM_RESULTS = 10;
-const ALLOW_ALL_SHELL_ENV = "BEST_AGENT_ALLOW_ALL_SHELL";
-const EXTRA_READABLE_ROOTS_ENV = "BEST_AGENT_EXTRA_READABLE_ROOTS";
-function resolveRuntimeContextTokenBudget() {
-    const raw = process.env.BEST_AGENT_CONTEXT_TOKEN_BUDGET ?? process.env.DIMCODE_CONTEXT_WINDOW;
-    if (!raw) {
-        return undefined;
-    }
-    const parsed = Number(raw);
-    return Number.isFinite(parsed) && parsed >= 256 ? Math.floor(parsed) : undefined;
-}
-function normalizePlainText(value) {
-    return String(value ?? "").trim();
-}
-function normalizeOptionalText(value) {
-    const next = normalizePlainText(value);
-    return next || undefined;
-}
-function parsePositiveInt(value) {
-    const normalized = normalizePlainText(value);
-    if (!normalized) {
-        return undefined;
-    }
-    const parsed = Number.parseInt(normalized, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
-}
-export function resolveCliReadableRoots(cwd) {
-    const roots = [resolve(cwd ?? process.cwd())];
-    const raw = normalizeOptionalText(process.env[EXTRA_READABLE_ROOTS_ENV]);
-    if (!raw) {
-        return roots;
-    }
-    for (const entry of raw.split(delimiter)) {
-        const normalized = normalizeOptionalText(entry);
-        if (!normalized) {
-            continue;
-        }
-        roots.push(resolve(normalized));
-    }
-    return Array.from(new Set(roots));
-}
-export function resolveCliAllowAllShell() {
-    const raw = normalizePlainText(process.env[ALLOW_ALL_SHELL_ENV]).toLowerCase();
-    return raw === "1" || raw === "true" || raw === "yes" || raw === "on";
-}
-function buildCliWebSearchQuery(input) {
-    const query = normalizePlainText(input.query);
-    const domains = (input.domains ?? [])
-        .map((domain) => normalizeOptionalText(domain))
-        .filter((domain) => Boolean(domain));
-    if (domains.length === 0) {
-        return query;
-    }
-    if (domains.length === 1) {
-        return `${query} site:${domains[0]}`;
-    }
-    return `${query} (${domains.map((domain) => `site:${domain}`).join(" OR ")})`;
-}
-function selectCliWebSearchResults(payload) {
-    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-        return [];
-    }
-    const organic = payload.organic;
-    if (!Array.isArray(organic)) {
-        return [];
-    }
-    return organic.flatMap((entry) => {
-        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-            return [];
-        }
-        const record = entry;
-        const link = normalizeOptionalText(record.link);
-        if (!link) {
-            return [];
-        }
-        return [
-            {
-                link,
-                snippet: normalizeOptionalText(record.snippet),
-                title: normalizeOptionalText(record.title),
-            },
-        ];
-    });
-}
-function formatCliWebSearchResults(input) {
-    const lines = [`Search results for "${input.query}" (${input.results.length} found):`];
-    if (input.results.length === 0) {
-        lines.push("No results found.");
-        return lines.join("\n");
-    }
-    input.results.forEach((result, index) => {
-        lines.push(`${index + 1}. ${result.title ?? result.link}`);
-        lines.push(`   URL: ${result.link}`);
-        if (result.snippet) {
-            lines.push(`   Snippet: ${result.snippet}`);
-        }
-    });
-    return lines.join("\n");
-}
-async function loadCliWebSearchAdapter() {
-    const dimcodeHome = String(process.env.DIMCODE_HOME ?? "").trim() || join(homedir(), ".dimcode");
-    const toolsPath = join(dimcodeHome, "tools.json");
-    if (!existsSync(toolsPath)) {
-        return undefined;
-    }
-    let settings;
-    try {
-        const parsed = JSON.parse(readFileSync(toolsPath, "utf8"));
-        settings = parsed.settings?.websearch;
-    }
-    catch {
-        return undefined;
-    }
-    if (!settings) {
-        return undefined;
-    }
-    const apiEndpoint = normalizeOptionalText(settings.apiEndpoint) ?? DEFAULT_WEB_SEARCH_API_ENDPOINT;
-    const apiKey = normalizeOptionalText(settings.apiKey);
-    const numResults = parsePositiveInt(settings.numResults) ?? DEFAULT_WEB_SEARCH_NUM_RESULTS;
-    return {
-        webSearchAvailability: () => Boolean(apiKey),
-        webSearch: async (input) => {
-            if (!apiKey) {
-                return "Web search is not available in this runtime. Use fetch-url with a known URL or ask the user for a source.";
-            }
-            const limit = Math.min(parsePositiveInt(input.limit) ?? numResults, DEFAULT_WEB_SEARCH_NUM_RESULTS);
-            const response = await globalThis.fetch(apiEndpoint, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "X-API-KEY": apiKey,
-                },
-                body: JSON.stringify({
-                    num: limit,
-                    q: buildCliWebSearchQuery(input),
-                }),
-            });
-            if (!response.ok) {
-                throw new Error(`Web search request failed with ${response.status} ${response.statusText}: ${await response.text()}`);
-            }
-            const payload = await response.json();
-            return formatCliWebSearchResults({
-                query: normalizePlainText(input.query),
-                results: selectCliWebSearchResults(payload).slice(0, limit),
-            });
-        },
-    };
-}
-export async function createCliRuntime(options, injected) {
-    return await withStartupSpanAsync("cliRuntime.create", undefined, async () => {
-        return await withPerfSpanAsync("createCliRuntime", undefined, async () => {
-            const extensionRoot = options.extensionsRoot ?? process.env.BEST_AGENT_EXTENSIONS_ROOT;
-            const extensionRegistry = withStartupSpan("cliRuntime.loadExtensionRegistry", undefined, () => withPerfSpan("loadExtensionRegistry", undefined, () => loadExtensionRegistry(extensionRoot)));
-            const commandTools = withStartupSpan("cliRuntime.loadCommandTools", undefined, () => withPerfSpan("loadCommandTools", undefined, () => loadCommandTools(extensionRegistry)));
-            const mcpTools = withStartupSpan("cliRuntime.loadMcpTools", undefined, () => withPerfSpan("loadMcpTools", undefined, () => loadMcpTools(extensionRegistry)));
-            const extensionSkills = await withStartupSpanAsync("cliRuntime.loadSkills", `static=${extensionRegistry.getSkills().length} command=${extensionRegistry.getCommandSkills().length}`, () => withPerfSpanAsync("loadSkills", undefined, () => loadSkills(extensionRegistry)));
-            const storageRoot = withStartupSpan("cliRuntime.resolveStorageRoot", undefined, () => resolveCliStorageRoot(options));
-            const persistedState = injected?.persistedState ??
-                withStartupSpan("cliRuntime.readPersistedState", undefined, () => readCliPersistedState(storageRoot));
-            const providerConfig = options.providerConfig ?? persistedState?.providerConfig;
-            const normalizedProviderConfig = providerConfig
-                ? enrichProviderConfig(providerConfig)
-                : undefined;
-            const contextTokenBudget = resolveRuntimeContextTokenBudget();
-            const webSearchAdapter = await withStartupSpanAsync("cliRuntime.loadWebSearchAdapter", undefined, () => withPerfSpanAsync("loadCliWebSearchAdapter", undefined, () => loadCliWebSearchAdapter()));
-            const agentProfiles = withStartupSpan("cliRuntime.loadAgentProfiles", undefined, () => loadAgentProfiles(extensionRegistry));
-            const tools = withStartupSpan("cliRuntime.createToolRegistry", undefined, () => createDefaultToolRegistry([...commandTools, ...mcpTools]));
-            const runtime = withStartupSpan("cliRuntime.instantiateAgentRuntime", `profiles=${agentProfiles.length} skills=${extensionSkills.length} commandTools=${commandTools.length} mcpTools=${mcpTools.length}`, () => new AgentRuntime({
-                ...options,
-                providerConfig: normalizedProviderConfig,
-                storageRoot,
-                ...(contextTokenBudget ? { memory: { contextTokenBudget } } : {}),
-                agentProfiles,
-                policy: createDefaultRuntimePolicy({
-                    allowedTools: [
-                        ...DEFAULT_ALLOWED_TOOLS,
-                        ...commandTools.map((tool) => tool.name),
-                        ...mcpTools.map((tool) => tool.name),
-                    ],
-                    allowAllShell: resolveCliAllowAllShell(),
-                    cwd: options.cwd,
-                    readableRoots: resolveCliReadableRoots(options.cwd),
-                    writableRoots: [`${storageRoot}/threads`],
-                }),
-                skills: extensionSkills,
-                tools,
-                ...(webSearchAdapter
-                    ? {
-                        webSearch: webSearchAdapter.webSearch,
-                        webSearchAvailability: webSearchAdapter.webSearchAvailability,
-                    }
-                    : {}),
-            }));
-            markStartup("cliRuntime.ready", `profiles=${agentProfiles.length} skills=${extensionSkills.length} commandTools=${commandTools.length} mcpTools=${mcpTools.length}`);
-            return runtime;
-        });
-    });
-}
-export function readCliPersistedState(storageRoot) {
-    const filePath = cliStatePath(storageRoot);
-    if (!existsSync(filePath)) {
-        return undefined;
-    }
-    try {
-        const parsed = JSON.parse(readFileSync(filePath, "utf8"));
-        return parseCliPersistedState(parsed);
-    }
-    catch { }
-    return undefined;
-}
-function parseCliPersistedState(value) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    const dimsdk = parsePersistedDimSdkState(value.dimsdk);
-    const providerConfig = parsePersistedProviderConfig(value.providerConfig);
-    return {
-        ...(dimsdk ? { dimsdk } : {}),
-        ...(providerConfig ? { providerConfig } : {}),
-    };
-}
-function parsePersistedDimSdkState(value) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    return isRecord(value.providerState) ? { providerState: value.providerState } : {};
-}
-function parsePersistedProviderConfig(value) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    const kind = parseProviderKind(readOptionalString(value.kind));
-    const model = readOptionalString(value.model);
-    if (!kind || !model) {
-        return undefined;
-    }
-    const compatibilityMode = parseOptionalPersistedProviderCompatibilityMode(value.compatibilityMode);
-    const decisionTransport = parseOptionalPersistedProviderDecisionTransport(value.decisionTransport);
-    if (compatibilityMode === "invalid" || decisionTransport === "invalid") {
-        return undefined;
-    }
-    return enrichProviderConfig({
-        kind,
-        model,
-        apiKey: readOptionalString(value.apiKey),
-        baseURL: readOptionalString(value.baseURL),
-        compatibilityMode,
-        decisionTransport,
-        maxInputTokens: readOptionalPositiveNumber(value.maxInputTokens),
-        maxOutputTokens: readOptionalPositiveNumber(value.maxOutputTokens),
-        systemPrompt: readOptionalString(value.systemPrompt),
-        timeoutMs: readOptionalPositiveNumber(value.timeoutMs),
-    });
-}
-function parseOptionalPersistedProviderCompatibilityMode(value) {
-    if (value == null) {
-        return undefined;
-    }
-    return parseProviderCompatibilityMode(readOptionalString(value)) ?? "invalid";
-}
-function parseOptionalPersistedProviderDecisionTransport(value) {
-    if (value == null) {
-        return undefined;
-    }
-    const raw = readOptionalString(value);
-    if (!raw) {
-        return "invalid";
-    }
-    try {
-        return parseProviderDecisionTransportMode(raw);
-    }
-    catch {
-        return "invalid";
-    }
-}
-export function writeCliPersistedState(storageRoot, state) {
-    const filePath = cliStatePath(storageRoot);
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, JSON.stringify(state, null, 2));
-}
-export function hydrateDimSdkProviderSelection(state, input) {
-    const nextProviderState = input.persistedProviderState
-        ? cloneJson(input.persistedProviderState)
-        : input.providerConfig
-            ? providerStateFromProviderConfig(input.providerConfig)
-            : undefined;
-    if (!nextProviderState) {
-        return;
-    }
-    replaceObjectContents(state.provider, nextProviderState);
-    const activeId = normalizeText(state.provider.activeId);
-    const activeModelByProvider = asRecord(state.provider.activeModelByProvider);
-    const nextModel = (activeId ? normalizeText(activeModelByProvider[activeId]) : undefined) ??
-        input.providerConfig?.model;
-    if (nextModel) {
-        state.config.model = nextModel;
-    }
-}
-export function resolveProviderConfigFromDimSdkState(state, fallback) {
-    const providerState = asRecord(state.provider);
-    const activeId = normalizeText(providerState.activeId);
-    const activeModelByProvider = asRecord(providerState.activeModelByProvider);
-    const model = normalizeText(state.config?.model) ??
-        (activeId ? normalizeText(activeModelByProvider[activeId]) : undefined) ??
-        normalizeText(fallback?.model);
-    if (!model) {
-        return undefined;
-    }
-    const customProviders = Array.isArray(providerState.customProviders)
-        ? providerState.customProviders
-        : [];
-    const customProvider = activeId?.startsWith("cp_")
-        ? customProviders.find((candidate) => normalizeText(candidate?.id) === activeId)
-        : undefined;
-    const customConfig = asRecord(customProvider);
-    const legacyCustom = asRecord(providerState.custom);
-    const connections = asRecord(providerState.connections);
-    const connection = (activeId === "custom" ? legacyCustom : activeId ? asRecord(connections[activeId]) : {});
-    const adapter = normalizeText(customConfig.adapter);
-    const kind = resolveProviderKind(activeId, adapter, fallback?.kind);
-    if (!kind) {
-        return fallback ? { ...fallback, model } : undefined;
-    }
-    const baseURL = normalizeText(customConfig.baseUrl) ??
-        normalizeText(connection.baseUrl) ??
-        normalizeText(legacyCustom.baseUrl) ??
-        normalizeText(fallback?.baseURL);
-    const apiKey = normalizeText(customConfig.apiKey) ??
-        normalizeText(connection.apiKey) ??
-        normalizeText(legacyCustom.apiKey) ??
-        normalizeText(fallback?.apiKey);
-    const nextConfig = {
-        compatibilityMode: fallback?.compatibilityMode,
-        kind,
-        model,
-        ...(typeof fallback?.maxInputTokens === "number"
-            ? { maxInputTokens: fallback.maxInputTokens }
-            : {}),
-        ...(typeof fallback?.maxOutputTokens === "number"
-            ? { maxOutputTokens: fallback.maxOutputTokens }
-            : {}),
-        systemPrompt: fallback?.systemPrompt,
-        timeoutMs: fallback?.timeoutMs,
-    };
-    if (apiKey) {
-        nextConfig.apiKey = apiKey;
-    }
-    if (baseURL) {
-        nextConfig.baseURL = baseURL;
-    }
-    return enrichProviderConfig(nextConfig);
-}
-function providerStateFromProviderConfig(providerConfig) {
-    const providerId = DIMSDK_ID_BY_PROVIDER_KIND[providerConfig.kind];
-    const activeModelByProvider = providerId ? { [providerId]: providerConfig.model } : {};
-    if (providerConfig.kind === "customProvider") {
-        return {
-            activeId: "custom",
-            activeModelByProvider,
-            connections: {},
-            custom: {
-                apiKey: providerConfig.apiKey,
-                baseUrl: providerConfig.baseURL,
-                models: providerConfig.model ? [{ id: providerConfig.model }] : [],
-            },
-            customProviders: [],
-        };
-    }
-    return {
-        activeId: providerId,
-        activeModelByProvider,
-        connections: providerId
-            ? {
-                [providerId]: {
-                    apiKey: providerConfig.apiKey,
-                    baseUrl: providerConfig.baseURL,
-                },
-            }
-            : {},
-        custom: {
-            apiKey: undefined,
-            baseUrl: undefined,
-            models: [],
-        },
-        customProviders: [],
-    };
-}
-function resolveProviderKind(providerId, adapter, fallback) {
-    if (providerId?.startsWith("cp_")) {
-        return PROVIDER_KIND_BY_DIMSDK_ID[adapter ?? ""] ?? fallback ?? "customProvider";
-    }
-    return (PROVIDER_KIND_BY_DIMSDK_ID[providerId ?? ""] ??
-        PROVIDER_KIND_BY_DIMSDK_ID[adapter ?? ""] ??
-        fallback);
-}
-function replaceObjectContents(target, source) {
-    for (const key of Object.keys(target)) {
-        delete target[key];
-    }
-    Object.assign(target, source);
-}
-function asRecord(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return {};
-    }
-    return value;
-}
-function normalizeText(value) {
-    return readOptionalString(value);
-}
-function readOptionalString(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function readOptionalPositiveNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
-}
-function cloneJson(value) {
-    return JSON.parse(JSON.stringify(value ?? null));
-}
-function loadAgentProfiles(registry) {
-    return registry.getAgentProfiles().map((profile) => ({
-        allowedTools: profile.allowedTools ?? [],
-        defaultSkills: (profile.defaultSkills ?? []).map((skillName) => `skill:${profile.sourceExtension}:${skillName}`),
-        description: profile.description,
-        name: profile.name,
-        source: "extension",
-        systemPrompt: profile.systemPrompt,
-    }));
-}
-async function loadSkills(registry) {
-    return (await resolveInstalledExtensionSkills(registry, async ({ args, command, cwd }) => new LocalSandbox().runCommand([command, ...args], cwd))).map((skill) => ({
-        allowedTools: skill.allowedTools,
-        content: skill.content,
-        contextMode: skill.contextMode,
-        description: skill.description,
-        effort: skill.effort,
-        executionMode: skill.executionMode,
-        id: `skill:${skill.sourceExtension}:${skill.name}`,
-        model: skill.model,
-        name: skill.name,
-        pathScope: skill.pathScope,
-        source: "extension",
-        sourceExtension: skill.sourceExtension,
-        whenToUse: skill.whenToUse,
-    }));
-}
-export function loadMcpTools(registry) {
-    return registry.listMcpServers().flatMap((server) => server.tools.map((tool) => createMcpToolDefinition({
-        args: server.args,
-        command: server.command,
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        sourceExtension: server.sourceExtension,
-        serverName: server.name,
-        toolName: tool.name,
-    })));
-}
-function loadCommandTools(registry) {
-    return registry.getCommandTools().map((tool) => createCommandToolDefinition({
-        args: tool.args,
-        command: tool.command,
-        description: tool.description,
-        extensionName: tool.sourceExtension,
-        toolName: tool.name,
-    }));
-}
-function cliStatePath(storageRoot) {
-    return join(storageRoot, "cli-state.json");
-}
-//# sourceMappingURL=runtime.js.map