aws-runtime-bridge 1.7.48 → 1.7.50

package/package/acode/dist/runtime.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter } from 'node:events';
+import type { ACodeRuntimeConfig } from './types.js';
+export declare class ACodeRuntime extends EventEmitter {
+    private readonly config;
+    private readonly hookBus;
+    private state;
+    private abortController;
+    constructor(config: ACodeRuntimeConfig);
+    private emitAcodeEvent;
+    /**
+     * 启动 ACode headless 会话。
+     * 主流程：加载 `.acode/config.json` 与 skills 目录 -> 发出 MCP/Skill 状态 ->
+     * 如有初始 prompt 则执行一轮响应。
+     */
+    start(): Promise<void>;
+    /**
+     * 处理一轮用户输入。
+     * 主流程：将用户输入追加到会话 -> 调用 OpenAI-compatible 模型 -> 如模型请求
+     * MCP tool call 则执行工具并继续同一轮，最后输出 assistant 文本与 usage。
+     */
+    submit(message: string): Promise<void>;
+    /** 中止当前轮次；当前骨架无长任务，仅发出完成状态。 */
+    abort(): Promise<void>;
+    /** 终止 ACode 会话并发出 session_complete。 */
+    stop(): Promise<void>;
+    private resolveCommandDirs;
+    private runModelTurn;
+    private requestChatCompletion;
+    private handleToolCalls;
+    private connectMcpServers;
+    private createMcpTransport;
+    private disconnectMcpServers;
+}
+//# sourceMappingURL=runtime.d.ts.map

package/package/acode/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAa3C,OAAO,KAAK,EAOV,kBAAkB,EAEnB,MAAM,YAAY,CAAC;AA6PpB,qBAAa,YAAa,SAAQ,YAAY;IAmBhC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAlBnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IAEvC,OAAO,CAAC,KAAK,CAYX;IAEF,OAAO,CAAC,eAAe,CAAgC;gBAE1B,MAAM,EAAE,kBAAkB;IAevD,OAAO,CAAC,cAAc;IAUtB;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAuE5B;;;;OAIG;IACG,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA+C5C,+BAA+B;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B,uCAAuC;IACjC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAU3B,OAAO,CAAC,kBAAkB;YASZ,YAAY;YA6BZ,qBAAqB;YA+BrB,eAAe;YAiFf,iBAAiB;IA8B/B,OAAO,CAAC,kBAAkB;YAuBZ,oBAAoB;CAYnC"}

package/package/acode/dist/runtime.js

@@ -0,0 +1,571 @@
+import { EventEmitter } from 'node:events';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { createBuiltInFileTools } from './built-in-file-tools.js';
+import { loadAcodeCommands } from './commands/commandLoader.js';
+import { ACodeCommandRegistry } from './commands/commandRegistry.js';
+import { loadAcodeConfig, loadAcodeSkills } from './config.js';
+import { ACodeHookBus, findDeniedHookResult } from './hooks/hookBus.js';
+function nowIso() {
+    return new Date().toISOString();
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function isJsonObject(value) {
+    return isRecord(value);
+}
+function normalizeText(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+/**
+ * 解析 ACode 当前会话模型：优先显式启动参数，其次兼容 cc-switch 写入的
+ * OpenCode-style `provider.default.model`，最后回落到旧版 top-level model。
+ */
+function resolveProviderConfig(config, acodeConfig) {
+    const defaultProvider = acodeConfig.provider?.default;
+    const providerOptions = defaultProvider?.options;
+    return {
+        model: config.model || defaultProvider?.model || acodeConfig.model || 'acode-default',
+        baseURL: normalizeText(providerOptions?.baseURL || providerOptions?.baseUrl),
+        apiKey: normalizeText(providerOptions?.apiKey),
+        systemPrompt: config.systemPrompt || acodeConfig.systemPrompt,
+    };
+}
+/**
+ * 解析 ACode 工具权限配置。
+ * 主流程：运行时配置优先 -> `.acode/config.json` 次之 -> 兼容旧式 allowedTools/deniedTools 字段。
+ */
+function resolvePermissionConfig(config, acodeConfig) {
+    const configured = config.permissions ?? acodeConfig.permissions ?? {};
+    const legacyAllow = config.permissions ? [] : acodeConfig.allowedTools ?? [];
+    const legacyDeny = config.permissions ? [] : acodeConfig.deniedTools ?? [];
+    return {
+        mode: configured.mode ?? 'default',
+        allow: [...(configured.allow ?? []), ...legacyAllow].map((rule) => rule.trim()).filter(Boolean),
+        deny: [...(configured.deny ?? []), ...legacyDeny].map((rule) => rule.trim()).filter(Boolean),
+    };
+}
+function wildcardMatches(pattern, value) {
+    if (pattern === '*') {
+        return true;
+    }
+    if (pattern.endsWith('*')) {
+        return value.startsWith(pattern.slice(0, -1));
+    }
+    return pattern === value;
+}
+function toolPermissionNames(tool) {
+    if (tool.kind === 'builtin') {
+        return [tool.exposedName, tool.toolName, `builtin.${tool.toolName}`];
+    }
+    return [tool.exposedName, tool.toolName, `${tool.serverName}.${tool.toolName}`, `mcp.${tool.serverName}.${tool.toolName}`];
+}
+function matchesToolRule(rule, tool) {
+    return toolPermissionNames(tool).some((name) => wildcardMatches(rule, name));
+}
+function assertToolAllowedByRules(tool, rules, message) {
+    if (rules.length > 0 && !rules.some((rule) => matchesToolRule(rule, tool))) {
+        throw new Error(message);
+    }
+}
+function assertToolPermission(tool, permissions, commandAllowedTools) {
+    if (permissions.mode === 'bypassPermissions') {
+        return;
+    }
+    if (permissions.deny.some((rule) => matchesToolRule(rule, tool))) {
+        throw new Error(`ACode tool denied by permission rule: ${tool.exposedName}`);
+    }
+    assertToolAllowedByRules(tool, permissions.allow, `ACode tool is not in allowed permission rules: ${tool.exposedName}`);
+    assertToolAllowedByRules(tool, commandAllowedTools ?? [], `ACode slash command does not allow tool: ${tool.exposedName}`);
+}
+function isToolAllowed(tool, permissions, commandAllowedTools) {
+    try {
+        assertToolPermission(tool, permissions, commandAllowedTools);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeChatCompletionsUrl(baseURL) {
+    const trimmed = baseURL.replace(/\/+$/g, '');
+    if (/\/chat\/completions$/i.test(trimmed)) {
+        return trimmed;
+    }
+    return `${trimmed}/chat/completions`;
+}
+function coerceArguments(rawArguments) {
+    try {
+        const parsed = JSON.parse(rawArguments);
+        return isJsonObject(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function createFallbackResponse(message, state) {
+    const trimmed = message.trim();
+    return `ACode 已接收任务。当前已加载 ${state.configMcpCount} 个 MCP 配置、${state.exposedTools.length} 个 MCP Tool 与 ${state.skills.length} 个 Skill。${trimmed ? `输入摘要：${trimmed.slice(0, 200)}` : ''}`;
+}
+function toToolResultText(result) {
+    if (!isRecord(result)) {
+        return String(result ?? '');
+    }
+    const content = result.content;
+    if (Array.isArray(content)) {
+        const parts = content
+            .map((item) => {
+            if (!isRecord(item)) {
+                return '';
+            }
+            if (typeof item.text === 'string') {
+                return item.text;
+            }
+            return JSON.stringify(item);
+        })
+            .filter(Boolean);
+        if (parts.length > 0) {
+            return parts.join('\n');
+        }
+    }
+    return JSON.stringify(result);
+}
+function buildSkillPrompt(skills) {
+    if (skills.length === 0) {
+        return '';
+    }
+    return [
+        'Available skills:',
+        ...skills.map((skill) => `- ${skill.name}${skill.description ? `: ${skill.description}` : ''}`),
+        'Use these skills as guidance when they match the user task.',
+    ].join('\n');
+}
+function buildCommandPrompt(commands) {
+    if (commands.length === 0) {
+        return '';
+    }
+    return [
+        'Available slash commands:',
+        ...commands.map((command) => `- /${command.name}${command.description ? `: ${command.description}` : ''}`),
+        'When the user invokes a slash command, ACode expands it before model execution.',
+    ].join('\n');
+}
+function toOpenAiTools(tools) {
+    return tools.map((tool) => ({
+        type: 'function',
+        function: {
+            name: tool.exposedName,
+            description: tool.description || tool.toolName,
+            parameters: tool.inputSchema,
+        },
+    }));
+}
+function normalizeToolName(serverName, toolName) {
+    const normalized = `${serverName}__${toolName}`.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return normalized.slice(0, 64) || 'mcp_tool';
+}
+function buildRequestHeaders(provider) {
+    const headers = { 'Content-Type': 'application/json' };
+    if (provider.apiKey) {
+        headers.Authorization = `Bearer ${provider.apiKey}`;
+    }
+    return headers;
+}
+export class ACodeRuntime extends EventEmitter {
+    constructor(config) {
+        super();
+        this.config = config;
+        this.state = {
+            started: false,
+            terminated: false,
+            configMcpCount: 0,
+            skills: [],
+            provider: { model: 'acode-default' },
+            permissions: { mode: 'default', allow: [], deny: [] },
+            mcpConnections: [],
+            exposedTools: [],
+            commands: [],
+            commandRegistry: new ACodeCommandRegistry([]),
+            conversation: [],
+        };
+        this.abortController = null;
+        this.hookBus = new ACodeHookBus({
+            sessionId: config.sessionId,
+            onError: (event, error) => {
+                this.emitAcodeEvent('error', {
+                    message: `ACode hook failed: ${event.name}: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            },
+        });
+        for (const handler of config.hooks ?? []) {
+            this.hookBus.register(handler);
+        }
+    }
+    emitAcodeEvent(type, data) {
+        const event = {
+            type,
+            sessionId: this.config.sessionId,
+            timestamp: nowIso(),
+            data,
+        };
+        this.emit('event', event);
+    }
+    /**
+     * 启动 ACode headless 会话。
+     * 主流程：加载 `.acode/config.json` 与 skills 目录 -> 发出 MCP/Skill 状态 ->
+     * 如有初始 prompt 则执行一轮响应。
+     */
+    async start() {
+        const acodeConfig = await loadAcodeConfig(this.config.configPath);
+        const skills = await loadAcodeSkills(this.config.skillsDir);
+        const provider = resolveProviderConfig(this.config, acodeConfig);
+        const permissions = resolvePermissionConfig(this.config, acodeConfig);
+        const mcpConnections = await this.connectMcpServers(acodeConfig.mcpServers ?? {});
+        const builtInTools = createBuiltInFileTools(this.config.workingDirectory);
+        const exposedTools = [...builtInTools, ...mcpConnections.flatMap((connection) => connection.tools)];
+        const commandDirs = this.resolveCommandDirs(acodeConfig);
+        const commands = await loadAcodeCommands(commandDirs);
+        const commandRegistry = new ACodeCommandRegistry(commands);
+        const skillPrompt = buildSkillPrompt(skills);
+        const commandPrompt = buildCommandPrompt(commands);
+        const systemPrompt = [provider.systemPrompt, skillPrompt, commandPrompt]
+            .map((item) => item?.trim())
+            .filter((item) => Boolean(item))
+            .join('\n\n');
+        this.state = {
+            started: true,
+            terminated: false,
+            configMcpCount: Object.keys(acodeConfig.mcpServers ?? {}).length,
+            skills,
+            provider,
+            permissions,
+            mcpConnections,
+            exposedTools,
+            commands,
+            commandRegistry,
+            conversation: systemPrompt ? [{ role: 'system', content: systemPrompt }] : [],
+        };
+        await this.hookBus.dispatch('SessionStart', {
+            workingDirectory: this.config.workingDirectory,
+            model: provider.model,
+            commandCount: commands.length,
+        });
+        this.emitAcodeEvent('session_started', {
+            workingDirectory: this.config.workingDirectory,
+            model: provider.model,
+            commandCount: commands.length,
+        });
+        this.emitAcodeEvent('mcp_status', {
+            configPath: this.config.configPath,
+            installedCount: this.state.configMcpCount,
+            servers: Object.keys(acodeConfig.mcpServers ?? {}),
+            connectedCount: mcpConnections.length,
+            builtInToolCount: builtInTools.length,
+            toolCount: exposedTools.length,
+            permissionMode: permissions.mode,
+            allowedToolRules: permissions.allow,
+            deniedToolRules: permissions.deny,
+            tools: exposedTools.map((tool) => ({
+                name: tool.exposedName,
+                source: tool.kind === 'mcp' ? `${tool.serverName}.${tool.toolName}` : `builtin.${tool.toolName}`,
+            })),
+        });
+        this.emitAcodeEvent('skill_status', {
+            skillsDir: this.config.skillsDir,
+            installedCount: skills.length,
+            skills: skills.map((skill) => ({ name: skill.name, description: skill.description })),
+        });
+        this.emitAcodeEvent('command_status', {
+            action: 'commands_loaded',
+            installedCommandCount: commands.length,
+            commandDirs,
+            commands: commands.map((command) => ({ name: command.name, description: command.description })),
+        });
+        if (this.config.initialPrompt) {
+            await this.submit(this.config.initialPrompt);
+        }
+    }
+    /**
+     * 处理一轮用户输入。
+     * 主流程：将用户输入追加到会话 -> 调用 OpenAI-compatible 模型 -> 如模型请求
+     * MCP tool call 则执行工具并继续同一轮，最后输出 assistant 文本与 usage。
+     */
+    async submit(message) {
+        if (!this.state.started || this.state.terminated) {
+            throw new Error('ACode runtime is not active');
+        }
+        const originalPrompt = message.trim();
+        const promptHookResults = await this.hookBus.dispatch('UserPromptSubmit', { prompt: originalPrompt });
+        const promptDeny = findDeniedHookResult(promptHookResults);
+        if (promptDeny) {
+            this.emitAcodeEvent('error', { message: promptDeny.message || 'ACode prompt was denied by hook' });
+            this.emitAcodeEvent('turn_complete', { failed: true });
+            return;
+        }
+        const expandedCommand = this.state.commandRegistry.expand(originalPrompt);
+        const trimmed = expandedCommand?.prompt.trim() || originalPrompt;
+        const commandAllowedTools = expandedCommand?.command.allowedTools;
+        if (expandedCommand) {
+            this.emitAcodeEvent('command_status', {
+                action: 'slash_command',
+                command: expandedCommand.command.name,
+                arguments: expandedCommand.argumentsText,
+                sourcePath: expandedCommand.command.sourcePath,
+            });
+        }
+        if (!this.state.provider.baseURL || !this.state.provider.apiKey) {
+            const text = createFallbackResponse(trimmed, this.state);
+            this.emitAcodeEvent('assistant_delta', { text });
+            this.emitAcodeEvent('turn_complete', { usage: { inputTokens: trimmed.length, outputTokens: text.length } });
+            return;
+        }
+        this.state.conversation.push({ role: 'user', content: trimmed });
+        try {
+            const result = await this.runModelTurn(commandAllowedTools);
+            if (result.text) {
+                this.emitAcodeEvent('assistant_delta', { text: result.text });
+            }
+            this.emitAcodeEvent('turn_complete', {
+                usage: result.usage ?? { inputTokens: trimmed.length, outputTokens: result.text.length },
+            });
+        }
+        catch (error) {
+            this.emitAcodeEvent('error', {
+                message: error instanceof Error ? error.message : String(error),
+            });
+            this.emitAcodeEvent('turn_complete', { failed: true });
+        }
+    }
+    /** 中止当前轮次；当前骨架无长任务，仅发出完成状态。 */
+    async abort() {
+        this.abortController?.abort();
+        this.abortController = null;
+        if (!this.state.terminated) {
+            this.emitAcodeEvent('turn_complete', { aborted: true });
+        }
+    }
+    /** 终止 ACode 会话并发出 session_complete。 */
+    async stop() {
+        if (this.state.terminated) {
+            return;
+        }
+        await this.disconnectMcpServers();
+        await this.hookBus.dispatch('Stop', { reason: 'session_stop' });
+        this.state.terminated = true;
+        this.emitAcodeEvent('session_complete', { exitCode: 0 });
+    }
+    resolveCommandDirs(acodeConfig) {
+        const configured = [
+            ...(this.config.commandDirs ?? []),
+            ...(acodeConfig.commandDirs ?? []),
+            ...(acodeConfig.commands?.directories ?? []),
+        ];
+        return [...new Set(configured.map((directory) => directory.trim()).filter(Boolean))];
+    }
+    async runModelTurn(commandAllowedTools) {
+        let finalText = '';
+        let finalUsage;
+        for (let step = 0; step < 5; step += 1) {
+            const response = await this.requestChatCompletion(commandAllowedTools);
+            const choice = response.choices?.[0];
+            const message = choice?.message;
+            const content = typeof message?.content === 'string' ? message.content : '';
+            const toolCalls = Array.isArray(message?.tool_calls) ? message.tool_calls : [];
+            finalUsage = {
+                inputTokens: response.usage?.prompt_tokens ?? response.usage?.input_tokens ?? 0,
+                outputTokens: response.usage?.completion_tokens ?? response.usage?.output_tokens ?? 0,
+            };
+            this.state.conversation.push({
+                role: 'assistant',
+                content: content || null,
+                tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+            });
+            if (content) {
+                finalText = content;
+            }
+            if (toolCalls.length === 0) {
+                return { text: finalText, usage: finalUsage };
+            }
+            await this.handleToolCalls(toolCalls, commandAllowedTools);
+        }
+        return { text: finalText || 'ACode 已达到本轮 MCP 工具调用上限。', usage: finalUsage };
+    }
+    async requestChatCompletion(commandAllowedTools) {
+        const provider = this.state.provider;
+        if (!provider.baseURL) {
+            throw new Error('ACode provider baseURL is not configured');
+        }
+        this.abortController = new AbortController();
+        const body = {
+            model: provider.model,
+            messages: this.state.conversation,
+            stream: false,
+        };
+        const allowedTools = this.state.exposedTools.filter((tool) => isToolAllowed(tool, this.state.permissions, commandAllowedTools));
+        if (allowedTools.length > 0) {
+            body.tools = toOpenAiTools(allowedTools);
+            body.tool_choice = 'auto';
+        }
+        const response = await fetch(normalizeChatCompletionsUrl(provider.baseURL), {
+            method: 'POST',
+            headers: buildRequestHeaders(provider),
+            body: JSON.stringify(body),
+            signal: this.abortController.signal,
+        });
+        this.abortController = null;
+        if (!response.ok) {
+            throw new Error(`ACode provider request failed: ${response.status} ${await response.text()}`);
+        }
+        const payload = await response.json();
+        return isRecord(payload) ? payload : {};
+    }
+    async handleToolCalls(toolCalls, commandAllowedTools) {
+        for (const toolCall of toolCalls) {
+            const tool = this.state.exposedTools.find((item) => item.exposedName === toolCall.function.name);
+            if (!tool) {
+                this.state.conversation.push({
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: `ACode MCP tool not found: ${toolCall.function.name}`,
+                });
+                continue;
+            }
+            if (tool.kind === 'builtin') {
+                const toolArguments = coerceArguments(toolCall.function.arguments);
+                assertToolPermission(tool, this.state.permissions, commandAllowedTools);
+                const preResults = await this.hookBus.dispatch('PreToolUse', {
+                    source: 'builtin',
+                    toolName: tool.toolName,
+                    exposedName: tool.exposedName,
+                    arguments: toolArguments,
+                });
+                const denied = findDeniedHookResult(preResults);
+                if (denied) {
+                    throw new Error(denied.message || `ACode tool denied by hook: ${tool.exposedName}`);
+                }
+                this.emitAcodeEvent('mcp_status', { action: 'call_tool', server: 'builtin', tool: tool.toolName });
+                const result = await tool.execute(toolArguments);
+                await this.hookBus.dispatch('PostToolUse', {
+                    source: 'builtin',
+                    toolName: tool.toolName,
+                    exposedName: tool.exposedName,
+                    result: toToolResultText(result),
+                });
+                this.state.conversation.push({
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: toToolResultText(result),
+                });
+                continue;
+            }
+            const connection = this.state.mcpConnections.find((item) => item.serverName === tool.serverName);
+            if (!connection) {
+                this.state.conversation.push({
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: `ACode MCP server not connected: ${tool.serverName}`,
+                });
+                continue;
+            }
+            const toolArguments = coerceArguments(toolCall.function.arguments);
+            assertToolPermission(tool, this.state.permissions, commandAllowedTools);
+            const preResults = await this.hookBus.dispatch('PreToolUse', {
+                source: 'mcp',
+                serverName: tool.serverName,
+                toolName: tool.toolName,
+                exposedName: tool.exposedName,
+                arguments: toolArguments,
+            });
+            const denied = findDeniedHookResult(preResults);
+            if (denied) {
+                throw new Error(denied.message || `ACode tool denied by hook: ${tool.exposedName}`);
+            }
+            this.emitAcodeEvent('mcp_status', { action: 'call_tool', server: tool.serverName, tool: tool.toolName });
+            const result = await connection.client.callTool({
+                name: tool.toolName,
+                arguments: toolArguments,
+            });
+            await this.hookBus.dispatch('PostToolUse', {
+                source: 'mcp',
+                serverName: tool.serverName,
+                toolName: tool.toolName,
+                exposedName: tool.exposedName,
+                result: toToolResultText(result),
+            });
+            this.state.conversation.push({
+                role: 'tool',
+                tool_call_id: toolCall.id,
+                content: toToolResultText(result),
+            });
+        }
+    }
+    async connectMcpServers(servers) {
+        const connections = [];
+        for (const [serverName, serverSpec] of Object.entries(servers)) {
+            try {
+                const client = new Client({ name: 'acode', version: '0.1.0' });
+                const transport = this.createMcpTransport(serverSpec);
+                await client.connect(transport);
+                const { tools } = await client.listTools();
+                connections.push({
+                    serverName,
+                    client,
+                    transport,
+                    tools: tools.map((tool) => ({
+                        serverName,
+                        toolName: tool.name,
+                        kind: 'mcp',
+                        exposedName: normalizeToolName(serverName, tool.name),
+                        description: tool.description,
+                        inputSchema: isJsonObject(tool.inputSchema) ? tool.inputSchema : { type: 'object', properties: {} },
+                    })),
+                });
+            }
+            catch (error) {
+                this.emitAcodeEvent('error', {
+                    message: `ACode MCP server failed to connect: ${serverName}: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        }
+        return connections;
+    }
+    createMcpTransport(serverSpec) {
+        if (serverSpec.type === 'stdio' || serverSpec.command) {
+            if (!serverSpec.command) {
+                throw new Error('stdio MCP server requires command');
+            }
+            return new StdioClientTransport({
+                command: serverSpec.command,
+                args: serverSpec.args,
+                cwd: serverSpec.cwd || this.config.workingDirectory,
+                env: { ...(this.config.env ?? {}), ...(serverSpec.env ?? {}) },
+                stderr: 'pipe',
+            });
+        }
+        if (!serverSpec.url) {
+            throw new Error('remote MCP server requires url');
+        }
+        const requestInit = serverSpec.headers ? { headers: serverSpec.headers } : undefined;
+        if (serverSpec.type === 'sse') {
+            return new SSEClientTransport(new URL(serverSpec.url), { requestInit });
+        }
+        return new StreamableHTTPClientTransport(new URL(serverSpec.url), { requestInit });
+    }
+    async disconnectMcpServers() {
+        const connections = this.state.mcpConnections;
+        this.state.mcpConnections = [];
+        this.state.exposedTools = [];
+        await Promise.all(connections.map(async (connection) => {
+            try {
+                await connection.transport.close();
+            }
+            catch {
+                // Best-effort shutdown; stale MCP transports must not block runtime termination.
+            }
+        }));
+    }
+}