@renxqoo/renx-code 0.0.1

package/dist/agent/runtime/runtime.js

@@ -0,0 +1,691 @@
+import { resolve as resolvePath } from 'node:path';
+import { resolveToolConfirmDecision } from './tool-confirmation';
+import { getSourceModules, resolveWorkspaceRoot, } from './source-modules';
+import { ToolCallBuffer } from './tool-call-buffer';
+import { buildSystemPrompt } from '../../agent/prompts/system';
+import { resolveRenxDatabasePath, resolveRenxTaskDir } from '../../config/paths';
+import { resolveAttachmentModelCapabilities } from '../../files/attachment-capabilities';
+let runtimePromise = null;
+let initializing = false;
+const readPreferredModelIdFromEnv = () => {
+    return process.env.AGENT_MODEL?.trim() || undefined;
+};
+let preferredModelId = readPreferredModelIdFromEnv();
+const DEFAULT_MODEL = 'qwen3.5-plus';
+const DEFAULT_MAX_STEPS = 10000;
+const DEFAULT_MAX_RETRY_COUNT = 10;
+const PARENT_HIDDEN_TOOL_NAMES = new Set(['file_history_list', 'file_history_restore']);
+const parsePositiveInt = (raw, fallback) => {
+    if (!raw || raw.trim().length === 0) {
+        return fallback;
+    }
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value) || value <= 0) {
+        return fallback;
+    }
+    return value;
+};
+const resolvePromptCacheConfig = (conversationId) => {
+    const rawPromptCacheKey = process.env.AGENT_PROMPT_CACHE_KEY?.trim();
+    const promptCacheRetention = process.env.AGENT_PROMPT_CACHE_RETENTION?.trim();
+    const promptCacheKey = rawPromptCacheKey?.replace(/\{conversationId\}/g, conversationId);
+    const config = {};
+    if (promptCacheKey) {
+        config.prompt_cache_key = promptCacheKey;
+    }
+    if (promptCacheRetention) {
+        config.prompt_cache_retention = promptCacheRetention;
+    }
+    return Object.keys(config).length > 0 ? config : undefined;
+};
+const resolveModelId = (modules, requested) => {
+    const ids = modules.ProviderRegistry.getModelIds();
+    const normalized = requested?.trim();
+    if (normalized && ids.includes(normalized)) {
+        return normalized;
+    }
+    if (ids.includes(DEFAULT_MODEL)) {
+        return DEFAULT_MODEL;
+    }
+    const fallback = ids[0];
+    if (!fallback) {
+        throw new Error('No models are registered in ProviderRegistry.');
+    }
+    return fallback;
+};
+const requireModelApiKey = (modules, modelId) => {
+    const modelConfig = modules.ProviderRegistry.getModelConfig(modelId);
+    if (!process.env[modelConfig.envApiKey]) {
+        throw new Error(`Missing env ${modelConfig.envApiKey} for model ${modelId}.`);
+    }
+    return modelConfig;
+};
+const resolveConversationId = () => {
+    const fromEnv = process.env.AGENT_CONVERSATION_ID?.trim() || process.env.AGENT_SESSION_ID?.trim();
+    if (fromEnv) {
+        return fromEnv;
+    }
+    return `opentui-${Date.now()}`;
+};
+const resolveDbPath = () => {
+    return resolveRenxDatabasePath(process.env);
+};
+const buildCliLoggerEnv = (env) => ({
+    ...env,
+    AGENT_LOG_CONSOLE: 'false',
+});
+const safeInvoke = (fn) => {
+    if (!fn) {
+        return;
+    }
+    try {
+        fn();
+    }
+    catch {
+        // Intentionally empty
+    }
+};
+const asRecord = (value) => {
+    return value && typeof value === 'object' ? value : {};
+};
+const readString = (value) => {
+    return typeof value === 'string' ? value : undefined;
+};
+const readNumber = (value) => {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+};
+const readBoolean = (value) => {
+    return typeof value === 'boolean' ? value : undefined;
+};
+const toUsageEventFromApp = (usage) => {
+    return {
+        promptTokens: usage.usage.prompt_tokens,
+        completionTokens: usage.usage.completion_tokens,
+        totalTokens: usage.usage.total_tokens,
+        cumulativePromptTokens: usage.cumulativeUsage.prompt_tokens,
+        cumulativeCompletionTokens: usage.cumulativeUsage.completion_tokens,
+        cumulativeTotalTokens: usage.cumulativeUsage.total_tokens,
+        contextTokens: typeof usage.contextTokens === 'number' && Number.isFinite(usage.contextTokens)
+            ? Math.max(0, usage.contextTokens)
+            : undefined,
+        contextLimit: usage.contextLimitTokens,
+        contextUsagePercent: typeof usage.contextUsagePercent === 'number' && Number.isFinite(usage.contextUsagePercent)
+            ? Math.max(0, usage.contextUsagePercent)
+            : undefined,
+    };
+};
+const toContextUsageEventFromApp = (usage) => {
+    if (typeof usage.stepIndex !== 'number' ||
+        !Number.isFinite(usage.stepIndex) ||
+        typeof usage.messageCount !== 'number' ||
+        !Number.isFinite(usage.messageCount) ||
+        typeof usage.contextTokens !== 'number' ||
+        !Number.isFinite(usage.contextTokens) ||
+        typeof usage.contextLimitTokens !== 'number' ||
+        !Number.isFinite(usage.contextLimitTokens) ||
+        typeof usage.contextUsagePercent !== 'number' ||
+        !Number.isFinite(usage.contextUsagePercent)) {
+        return null;
+    }
+    return {
+        stepIndex: Math.max(0, usage.stepIndex),
+        messageCount: Math.max(0, usage.messageCount),
+        contextTokens: Math.max(0, usage.contextTokens),
+        contextLimit: Math.max(0, usage.contextLimitTokens),
+        contextUsagePercent: Math.max(0, usage.contextUsagePercent),
+    };
+};
+const toJsonString = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+};
+const parseJsonObject = (raw) => {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object') {
+            return parsed;
+        }
+        return { value: parsed };
+    }
+    catch {
+        return { raw };
+    }
+};
+const toTextDeltaEvent = (payload, isReasoning) => {
+    return {
+        text: readString(payload.content) ?? readString(payload.reasoningContent) ?? '',
+        isReasoning,
+    };
+};
+const toStepEvent = (payload, finishReason, toolCallsCount = 0) => {
+    return {
+        stepIndex: readNumber(payload.stepIndex) ?? 0,
+        finishReason,
+        toolCallsCount,
+    };
+};
+const toLoopEvent = (stepIndex) => {
+    return {
+        loopIndex: stepIndex,
+        steps: stepIndex,
+    };
+};
+const toToolStreamEvent = (envelope, sequenceByToolCallId) => {
+    const payload = asRecord(envelope.data);
+    const toolCallId = readString(payload.toolCallId) ?? 'unknown';
+    const previousSequence = sequenceByToolCallId.get(toolCallId) ?? 0;
+    const sequence = previousSequence + 1;
+    sequenceByToolCallId.set(toolCallId, sequence);
+    return {
+        toolCallId,
+        toolName: readString(payload.toolName) ?? 'tool',
+        type: readString(payload.chunkType) ?? readString(payload.type) ?? 'stdout',
+        sequence,
+        timestamp: envelope.createdAt,
+        content: readString(payload.chunk) ?? readString(payload.content),
+        data: payload,
+    };
+};
+const toToolResultEvent = (payload, toolCallsById) => {
+    const toolCallId = readString(payload.tool_call_id) ?? readString(payload.toolCallId) ?? 'unknown';
+    const metadata = asRecord(payload.metadata);
+    const toolResult = asRecord(metadata.toolResult);
+    const error = asRecord(toolResult.error);
+    const summary = readString(toolResult.summary);
+    const explicitOutput = readString(toolResult.output);
+    const content = readString(payload.content);
+    const output = explicitOutput !== undefined ? explicitOutput : content !== summary ? content : undefined;
+    const toolCall = toolCallsById.get(toolCallId) ??
+        {
+            id: toolCallId,
+            function: { name: 'tool', arguments: '{}' },
+        };
+    return {
+        toolCall,
+        result: {
+            success: readBoolean(toolResult.success) ?? true,
+            error: readString(error.message),
+            data: {
+                ...(summary !== undefined ? { summary } : {}),
+                ...(output !== undefined ? { output } : {}),
+                ...(toolResult.payload !== undefined ? { payload: toolResult.payload } : {}),
+                ...(toolResult.metadata !== undefined ? { metadata: toolResult.metadata } : {}),
+            },
+            raw: payload,
+        },
+    };
+};
+const extractAssistantText = (result) => {
+    for (let i = result.messages.length - 1; i >= 0; i -= 1) {
+        const message = result.messages[i];
+        if (!message) {
+            continue;
+        }
+        if (message.role !== 'assistant') {
+            continue;
+        }
+        if (typeof message.content === 'string') {
+            return message.content;
+        }
+        return toJsonString(message.content);
+    }
+    return '';
+};
+const createRuntime = async () => {
+    const modules = await getSourceModules();
+    const workspaceRoot = resolveWorkspaceRoot();
+    await modules.loadEnvFiles(workspaceRoot);
+    modules.loadConfigToEnv({ projectRoot: workspaceRoot });
+    const conversationId = resolveConversationId();
+    const modelId = resolveModelId(modules, preferredModelId);
+    const modelConfig = requireModelApiKey(modules, modelId);
+    const maxSteps = parsePositiveInt(process.env.AGENT_MAX_STEPS, DEFAULT_MAX_STEPS);
+    const coreLogger = modules.createLoggerFromEnv(buildCliLoggerEnv(process.env), workspaceRoot);
+    const agentLogger = modules.createAgentLoggerAdapter(asRecord(coreLogger), {
+        runtime: 'renx-code',
+    });
+    const provider = modules.ProviderRegistry.createFromEnv(modelId, {
+        logger: asRecord(coreLogger),
+    });
+    const toolManager = new modules.DefaultToolManager();
+    const taskStore = new modules.TaskStore({
+        baseDir: resolveRenxTaskDir(process.env),
+    });
+    toolManager.registerTool(new modules.BashTool());
+    toolManager.registerTool(new modules.WriteFileTool({
+        allowedDirectories: [workspaceRoot],
+    }));
+    toolManager.registerTool(new modules.FileReadTool({
+        allowedDirectories: [workspaceRoot],
+    }));
+    toolManager.registerTool(new modules.FileEditTool({
+        allowedDirectories: [workspaceRoot],
+    }));
+    toolManager.registerTool(new modules.FileHistoryListTool({
+        allowedDirectories: [workspaceRoot],
+    }));
+    toolManager.registerTool(new modules.FileHistoryRestoreTool({
+        allowedDirectories: [workspaceRoot],
+    }));
+    toolManager.registerTool(new modules.GlobTool({
+        allowedDirectories: [workspaceRoot],
+    }));
+    toolManager.registerTool(new modules.GrepTool({
+        allowedDirectories: [workspaceRoot],
+    }));
+    toolManager.registerTool(new modules.SkillTool({
+        loaderOptions: {
+            workingDir: workspaceRoot,
+        },
+    }));
+    const agent = new modules.StatelessAgent(provider, toolManager, {
+        maxRetryCount: parsePositiveInt(process.env.AGENT_MAX_RETRY_COUNT, DEFAULT_MAX_RETRY_COUNT),
+        enableCompaction: true,
+        logger: agentLogger,
+    });
+    const appStore = modules.createSqliteAgentAppStore(resolveDbPath());
+    const preparableStore = appStore;
+    if (typeof preparableStore.prepare === 'function') {
+        await preparableStore.prepare();
+    }
+    const appService = new modules.AgentAppService({
+        agent,
+        executionStore: appStore,
+        eventStore: appStore,
+        messageStore: appStore,
+    });
+    const collectToolSchemas = () => toolManager
+        .getTools()
+        .map(tool => {
+        const schema = tool?.toToolSchema?.();
+        if (!schema || typeof schema !== 'object') {
+            return null;
+        }
+        return schema;
+    })
+        .filter((schema) => Boolean(schema));
+    const resolveToolSchemas = (allowedTools, hiddenToolNames) => {
+        const allSchemas = toolManager
+            ? collectToolSchemas().filter(schema => {
+                const name = schema.function?.name;
+                if (typeof name !== 'string') {
+                    return false;
+                }
+                return !hiddenToolNames?.has(name);
+            })
+            : [];
+        if (!allowedTools || allowedTools.length === 0) {
+            return allSchemas;
+        }
+        const allowed = new Set(allowedTools);
+        return allSchemas.filter(schema => {
+            const name = schema.function?.name;
+            return typeof name === 'string' && allowed.has(name);
+        });
+    };
+    const resolveSubagentToolSchemas = (allowedTools) => resolveToolSchemas(allowedTools, undefined);
+    const taskRunner = new modules.RealSubagentRunnerAdapter({
+        store: taskStore,
+        appService,
+        resolveTools: resolveSubagentToolSchemas,
+        // Use provider-level model name (e.g. MiniMax-M2.5), not registry id (e.g. minimax-2.5),
+        // so subagent requests match the same backend model as parent agent.
+        resolveModelId: () => modelConfig.model || modelId,
+    });
+    toolManager.registerTool(new modules.TaskCreateTool({
+        store: taskStore,
+        defaultNamespace: conversationId,
+    }));
+    toolManager.registerTool(new modules.TaskGetTool({
+        store: taskStore,
+        defaultNamespace: conversationId,
+    }));
+    toolManager.registerTool(new modules.TaskListTool({
+        store: taskStore,
+        defaultNamespace: conversationId,
+    }));
+    toolManager.registerTool(new modules.TaskUpdateTool({
+        store: taskStore,
+        defaultNamespace: conversationId,
+    }));
+    toolManager.registerTool(new modules.TaskTool({
+        store: taskStore,
+        runner: taskRunner,
+        defaultNamespace: conversationId,
+    }));
+    toolManager.registerTool(new modules.TaskStopTool({
+        store: taskStore,
+        runner: taskRunner,
+        defaultNamespace: conversationId,
+    }));
+    toolManager.registerTool(new modules.TaskOutputTool({
+        store: taskStore,
+        runner: taskRunner,
+        defaultNamespace: conversationId,
+    }));
+    const parentTools = resolveToolSchemas(undefined, PARENT_HIDDEN_TOOL_NAMES);
+    return {
+        modules,
+        modelId,
+        modelLabel: modelConfig.name,
+        maxSteps,
+        conversationId,
+        workspaceRoot,
+        parentTools,
+        agent,
+        appService,
+        appStore,
+        logger: coreLogger && typeof coreLogger === 'object'
+            ? coreLogger
+            : undefined,
+    };
+};
+const getRuntime = async () => {
+    // 双重检查锁定模式
+    if (runtimePromise) {
+        return runtimePromise;
+    }
+    if (initializing) {
+        // 等待初始化完成
+        while (initializing) {
+            await new Promise(resolve => setTimeout(resolve, 10));
+        }
+        // 初始化完成后，runtimePromise应该已经设置
+        if (runtimePromise) {
+            return runtimePromise;
+        }
+    }
+    // 开始初始化
+    initializing = true;
+    try {
+        const promise = createRuntime();
+        runtimePromise = promise;
+        // 如果初始化失败，允许重新尝试
+        promise.catch(() => {
+            runtimePromise = null;
+        });
+        return promise;
+    }
+    finally {
+        initializing = false;
+    }
+};
+const disposeRuntimeInstance = async () => {
+    const runtime = await runtimePromise;
+    runtimePromise = null;
+    if (!runtime) {
+        return;
+    }
+    await runtime.logger?.close?.();
+    await runtime.appStore.close();
+};
+export const runAgentPrompt = async (prompt, handlers, options = {}) => {
+    const runtime = await getRuntime();
+    const startedAt = Date.now();
+    const streamedState = {
+        text: '',
+        latestErrorMessage: undefined,
+        stopEmitted: false,
+        lastLoopStep: 0,
+    };
+    const toolStreamSequenceById = new Map();
+    const toolCallsById = new Map();
+    const toolCallBuffer = new ToolCallBuffer();
+    let latestUsageEvent;
+    let currentAction = 'llm';
+    const onToolConfirm = (event) => {
+        const rawArgs = parseJsonObject(event.arguments);
+        const toolConfirmEvent = {
+            toolCallId: event.toolCallId,
+            toolName: event.toolName,
+            args: rawArgs,
+            rawArgs,
+            reason: readString(event.reason),
+            metadata: event.metadata,
+        };
+        safeInvoke(() => handlers.onToolConfirm?.(toolConfirmEvent));
+        void resolveToolConfirmDecision(toolConfirmEvent, handlers)
+            .then(decision => {
+            event.resolve(decision);
+        })
+            .catch(error => {
+            const message = error instanceof Error ? error.message : String(error);
+            event.resolve({
+                approved: false,
+                message: message || 'Tool confirmation failed.',
+            });
+        });
+    };
+    runtime.agent.on('tool_confirm', onToolConfirm);
+    let result;
+    try {
+        const historyMessages = await runtime.appService.listContextMessages(runtime.conversationId);
+        result = await runtime.appService.runForeground({
+            conversationId: runtime.conversationId,
+            userInput: prompt,
+            historyMessages: historyMessages,
+            systemPrompt: buildSystemPrompt({ directory: runtime.workspaceRoot }),
+            tools: runtime.parentTools,
+            config: resolvePromptCacheConfig(runtime.conversationId),
+            maxSteps: runtime.maxSteps,
+            abortSignal: options.abortSignal,
+            modelLabel: runtime.modelLabel,
+        }, {
+            onError: (error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                if (message) {
+                    streamedState.latestErrorMessage = message;
+                }
+            },
+            onContextUsage: usage => {
+                const contextUsageEvent = toContextUsageEventFromApp(usage);
+                if (!contextUsageEvent) {
+                    return;
+                }
+                safeInvoke(() => handlers.onContextUsage?.(contextUsageEvent));
+            },
+            onUsage: usage => {
+                const usageEvent = toUsageEventFromApp(usage);
+                latestUsageEvent = usageEvent;
+                safeInvoke(() => handlers.onUsage?.(usageEvent));
+            },
+            onEvent: async (envelope) => {
+                const payload = asRecord(envelope.data);
+                switch (envelope.eventType) {
+                    case 'chunk': {
+                        const event = toTextDeltaEvent(payload, false);
+                        if (event.text.length > 0) {
+                            streamedState.text += event.text;
+                            safeInvoke(() => handlers.onTextDelta?.(event));
+                        }
+                        break;
+                    }
+                    case 'reasoning_chunk': {
+                        const event = toTextDeltaEvent(payload, true);
+                        if (event.text.length > 0) {
+                            safeInvoke(() => handlers.onTextDelta?.(event));
+                        }
+                        break;
+                    }
+                    case 'tool_stream': {
+                        const toolStreamEvent = toToolStreamEvent(envelope, toolStreamSequenceById);
+                        toolCallBuffer.ensureEmitted(toolStreamEvent.toolCallId, toolCall => {
+                            safeInvoke(() => handlers.onToolUse?.(toolCall));
+                        });
+                        safeInvoke(() => handlers.onToolStream?.(toolStreamEvent));
+                        break;
+                    }
+                    case 'tool_call': {
+                        const rawToolCalls = payload.toolCalls;
+                        if (Array.isArray(rawToolCalls) && rawToolCalls.length > 0) {
+                            for (const item of rawToolCalls) {
+                                const toolCall = asRecord(item);
+                                const toolCallId = readString(asRecord(toolCall).id);
+                                if (toolCallId) {
+                                    toolCallsById.set(toolCallId, toolCall);
+                                }
+                                toolCallBuffer.register(toolCall, event => {
+                                    safeInvoke(() => handlers.onToolUse?.(event));
+                                }, currentAction === 'tool');
+                            }
+                        }
+                        else {
+                            const toolCall = payload;
+                            const toolCallId = readString(asRecord(toolCall).id);
+                            if (toolCallId) {
+                                toolCallsById.set(toolCallId, toolCall);
+                            }
+                            toolCallBuffer.register(toolCall, event => {
+                                safeInvoke(() => handlers.onToolUse?.(event));
+                            }, currentAction === 'tool');
+                        }
+                        break;
+                    }
+                    case 'tool_result': {
+                        const toolCallId = readString(payload.tool_call_id) ?? readString(payload.toolCallId);
+                        toolCallBuffer.ensureEmitted(toolCallId, toolCall => {
+                            safeInvoke(() => handlers.onToolUse?.(toolCall));
+                        });
+                        const toolResultEvent = toToolResultEvent(payload, toolCallsById);
+                        safeInvoke(() => handlers.onToolResult?.(toolResultEvent));
+                        break;
+                    }
+                    case 'progress': {
+                        const nextAction = readString(payload.currentAction) ?? 'progress';
+                        currentAction = nextAction;
+                        const stepEvent = toStepEvent(payload, nextAction, 0);
+                        safeInvoke(() => handlers.onStep?.(stepEvent));
+                        if (nextAction === 'tool') {
+                            toolCallBuffer.flush(toolCall => {
+                                safeInvoke(() => handlers.onToolUse?.(toolCall));
+                            });
+                        }
+                        if (nextAction === 'llm' && stepEvent.stepIndex > streamedState.lastLoopStep) {
+                            streamedState.lastLoopStep = stepEvent.stepIndex;
+                            const loopEvent = toLoopEvent(stepEvent.stepIndex);
+                            safeInvoke(() => handlers.onLoop?.(loopEvent));
+                        }
+                        break;
+                    }
+                    case 'checkpoint': {
+                        const stepEvent = toStepEvent(payload, 'checkpoint', 0);
+                        safeInvoke(() => handlers.onStep?.(stepEvent));
+                        break;
+                    }
+                    case 'done': {
+                        safeInvoke(() => handlers.onTextComplete?.(streamedState.text));
+                        const stopEvent = {
+                            reason: readString(payload.finishReason) ?? 'stop',
+                        };
+                        safeInvoke(() => handlers.onStop?.(stopEvent));
+                        streamedState.stopEmitted = true;
+                        break;
+                    }
+                    case 'error': {
+                        const message = readString(payload.message);
+                        streamedState.latestErrorMessage = message;
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            },
+        });
+    }
+    finally {
+        runtime.agent.off('tool_confirm', onToolConfirm);
+    }
+    if (!streamedState.stopEmitted) {
+        safeInvoke(() => handlers.onTextComplete?.(streamedState.text));
+        safeInvoke(() => handlers.onStop?.({
+            reason: result.finishReason,
+            message: result.finishReason === 'error' ? result.run.errorMessage : undefined,
+        }));
+    }
+    const finalText = streamedState.text || extractAssistantText(result);
+    const completionMessage = result.finishReason === 'error'
+        ? (streamedState.latestErrorMessage ?? result.run.errorMessage)
+        : undefined;
+    return {
+        text: finalText,
+        completionReason: result.finishReason,
+        completionMessage,
+        durationSeconds: (Date.now() - startedAt) / 1000,
+        modelLabel: runtime.modelLabel,
+        usage: latestUsageEvent,
+    };
+};
+export const getAgentModelLabel = async () => {
+    const runtime = await getRuntime();
+    return runtime.modelLabel;
+};
+export const getAgentModelAttachmentCapabilities = async () => {
+    const modules = await getSourceModules();
+    const modelId = await getAgentModelId();
+    const config = modules.ProviderRegistry.getModelConfig(modelId);
+    return resolveAttachmentModelCapabilities(config);
+};
+export const getAgentModelId = async () => {
+    if (runtimePromise) {
+        const runtime = await runtimePromise;
+        if (runtime) {
+            return runtime.modelId;
+        }
+    }
+    const modules = await getSourceModules();
+    return resolveModelId(modules, preferredModelId);
+};
+export const listAgentModels = async () => {
+    const modules = await getSourceModules();
+    const currentModelId = await getAgentModelId();
+    return modules.ProviderRegistry.getModelIds()
+        .map(id => {
+        const config = modules.ProviderRegistry.getModelConfig(id);
+        return {
+            id,
+            name: config.name,
+            provider: config.provider ?? 'other',
+            apiKeyEnv: config.envApiKey,
+            configured: Boolean(process.env[config.envApiKey]),
+            current: id === currentModelId,
+        };
+    })
+        .sort((a, b) => {
+        if (a.provider !== b.provider) {
+            return a.provider.localeCompare(b.provider);
+        }
+        if (a.current !== b.current) {
+            return a.current ? -1 : 1;
+        }
+        return a.name.localeCompare(b.name);
+    });
+};
+export const switchAgentModel = async (modelId) => {
+    const modules = await getSourceModules();
+    const available = modules.ProviderRegistry.getModelIds();
+    if (!available.includes(modelId)) {
+        throw new Error(`Unknown model: ${modelId}`);
+    }
+    const config = modules.ProviderRegistry.getModelConfig(modelId);
+    if (!process.env[config.envApiKey]) {
+        throw new Error(`Missing env ${config.envApiKey} for model ${modelId}.`);
+    }
+    preferredModelId = modelId;
+    await disposeRuntimeInstance();
+    return {
+        modelId,
+        modelLabel: config.name,
+    };
+};
+export const disposeAgentRuntime = async () => {
+    await disposeRuntimeInstance();
+    preferredModelId = readPreferredModelIdFromEnv();
+};
+//# sourceMappingURL=runtime.js.map