@gt-fe/eap-runtime 0.0.8

package/dist/tool/dev-tool-executor.js

@@ -0,0 +1,55 @@
+/**
+ * DevToolExecutor — 本地 dev 总入口（不是 code 专用）
+ *
+ * 仅在 `EAP_TOOL_EXECUTION_MODE=mcp` 且 `deploymentContext=dev` 装配。
+ * 按清单分流，缺配置则失败，不回落 mock。
+ *
+ * - execution.protocol=mcp → DevMcpExecutor
+ * - execution.protocol=http → DevHttpExecutor
+ * - 能解析出 code handler → LocalToolExecutor
+ * - 其余 → NOT_CONFIGURED（mock 只走显式 `--tool-mode mock`）
+ */
+import { EmptyInstallStore } from './create-tool-executor.js';
+import { DevMcpExecutor } from './dev-mcp-executor.js';
+import { LocalToolExecutor, resolveCodeExecutionFromRequest, } from './local-tool-executor.js';
+import { DevHttpExecutor, resolveHttpExecutionFromRequest } from './dev-http-executor.js';
+export class DevToolExecutor {
+    mcp;
+    http;
+    local;
+    constructor(options = {}) {
+        this.mcp = new DevMcpExecutor(options.mcp);
+        this.http = new DevHttpExecutor();
+        this.local = new LocalToolExecutor({ installStore: new EmptyInstallStore() });
+    }
+    async execute(request) {
+        if (hasMcpExecution(request.execution)) {
+            return this.mcp.execute(request);
+        }
+        if (resolveHttpExecutionFromRequest(request)) {
+            return this.http.execute(request);
+        }
+        const codeSpec = resolveCodeExecutionFromRequest(request);
+        if (codeSpec) {
+            return this.local.execute({
+                ...request,
+                execution: { ...request.execution, localPreferred: true },
+            });
+        }
+        return {
+            toolCallId: request.toolCallId,
+            toolName: request.toolName,
+            content: '',
+            success: false,
+            error: `Dev tool "${request.toolName}" is not executable: no MCP server, ` +
+                'HTTP gateway+pathTemplate, or code handler. Use --tool-mode mock for MockToolExecutor.',
+            errorCode: 'NOT_CONFIGURED',
+            runtime: 'local',
+        };
+    }
+}
+function hasMcpExecution(raw) {
+    if (!raw || typeof raw !== 'object')
+        return false;
+    return raw.protocol === 'mcp';
+}

package/dist/tool/file-artifact.d.ts

@@ -0,0 +1,11 @@
+export interface FileArtifact {
+    fileName: string;
+    fileType: string;
+    size: number;
+    url: string;
+}
+export declare function parseJsonValue(value: unknown): unknown;
+export declare function extractFileReference(value: unknown): Record<string, unknown> | undefined;
+export declare function fileBasesFromEnv(serverEnv?: Record<string, string | undefined>): string[];
+export declare function resolveFileArtifact(ref: Record<string, unknown>, fileBases?: Array<string | undefined>): FileArtifact | undefined;
+export declare function fileArtifactFromToolOutput(content: unknown, fileBases?: Array<string | undefined>): FileArtifact | undefined;

package/dist/tool/file-artifact.js

@@ -0,0 +1,90 @@
+/**
+ * 从 Tool 输出里抽出通用文件产物（fileReference / 顶层 fileName+url）。
+ * 不认具体工具名。有公网 url 用 url；否则用 MCP_FILE_BASE_PATH 等根目录拼成本地 file://。
+ */
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+export function parseJsonValue(value) {
+    if (typeof value !== 'string')
+        return value;
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('{') && !trimmed.startsWith('['))
+        return value;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return value;
+    }
+}
+export function extractFileReference(value) {
+    const parsed = parseJsonValue(value);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return undefined;
+    const obj = parsed;
+    const nested = obj.fileReference;
+    if (nested && typeof nested === 'object' && !Array.isArray(nested)) {
+        return nested;
+    }
+    if (typeof obj.fileName === 'string'
+        && (typeof obj.url === 'string' || typeof obj.relativePath === 'string')) {
+        return obj;
+    }
+    return undefined;
+}
+export function fileBasesFromEnv(serverEnv) {
+    return [
+        serverEnv?.MCP_FILE_BASE_PATH,
+        process.env.MCP_FILE_BASE_PATH,
+        process.env.EAP_FILE_BASE_PATH,
+    ].filter((value) => Boolean(value?.trim()));
+}
+export function resolveFileArtifact(ref, fileBases = []) {
+    const relativePath = asString(ref.relativePath);
+    const fileName = asString(ref.fileName)
+        ?? (relativePath ? path.basename(relativePath) : undefined);
+    if (!fileName)
+        return undefined;
+    const fileType = asString(ref.format) ?? asString(ref.fileType) ?? extOf(fileName);
+    const size = typeof ref.size === 'number' && Number.isFinite(ref.size) ? ref.size : 0;
+    const explicitUrl = asString(ref.url);
+    if (explicitUrl) {
+        return { fileName, fileType, size, url: explicitUrl };
+    }
+    if (!relativePath || hasParentSegment(relativePath))
+        return undefined;
+    const bases = fileBases.filter((base) => Boolean(base?.trim()));
+    if (path.isAbsolute(relativePath)) {
+        const abs = path.resolve(relativePath);
+        if (bases.some((base) => isInside(base, abs)) && existsSync(abs)) {
+            return { fileName, fileType, size, url: pathToFileURL(abs).href };
+        }
+        return undefined;
+    }
+    for (const base of bases) {
+        const abs = path.resolve(base, relativePath);
+        if (!isInside(base, abs) || !existsSync(abs))
+            continue;
+        return { fileName, fileType, size, url: pathToFileURL(abs).href };
+    }
+    return undefined;
+}
+export function fileArtifactFromToolOutput(content, fileBases = []) {
+    const ref = extractFileReference(content);
+    return ref ? resolveFileArtifact(ref, fileBases) : undefined;
+}
+function asString(value) {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+function extOf(fileName) {
+    const ext = path.extname(fileName).replace(/^\./, '');
+    return ext || 'file';
+}
+function hasParentSegment(rel) {
+    return rel.split(/[\\/]/).some((part) => part === '..');
+}
+function isInside(root, target) {
+    const relativePath = path.relative(path.resolve(root), path.resolve(target));
+    return relativePath === '' || (!relativePath.startsWith(`..${path.sep}`) && relativePath !== '..');
+}

package/dist/tool/http-tool-executor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * HttpToolExecutor — 基于 HTTP 的 Tool 执行器实现
+ *
+ * @see docs/contracts/tool-execution.md §2
+ * @see docs/contracts/cross-service-api.md §4.6
+ */
+import type { IToolExecutor, ToolCallRequest, ToolCallResult } from './tool-executor.interface.js';
+export interface HttpToolExecutorOptions {
+    baseUrl: string;
+    timeout?: number;
+}
+export declare class HttpToolExecutor implements IToolExecutor {
+    private readonly baseUrl;
+    private readonly timeout;
+    constructor(options: HttpToolExecutorOptions);
+    execute(request: ToolCallRequest): Promise<ToolCallResult>;
+}

package/dist/tool/http-tool-executor.js

@@ -0,0 +1,158 @@
+/**
+ * HttpToolExecutor — 基于 HTTP 的 Tool 执行器实现
+ *
+ * @see docs/contracts/tool-execution.md §2
+ * @see docs/contracts/cross-service-api.md §4.6
+ */
+function mapGatewayHttpError(status, body, statusText) {
+    const code = body?.error?.code;
+    const message = body?.error?.message ?? body?.message ?? statusText;
+    if (status === 403) {
+        return {
+            error: message,
+            errorCode: code ?? 'NO_PERMISSION',
+            retryable: false,
+        };
+    }
+    if (status === 429) {
+        return {
+            error: message,
+            errorCode: code ?? 'RATE_LIMITED',
+            retryable: body?.error?.retryable ?? true,
+        };
+    }
+    if (status === 503) {
+        return {
+            error: message,
+            errorCode: code ?? 'CIRCUIT_OPEN',
+            retryable: body?.error?.retryable ?? true,
+        };
+    }
+    if (status === 404) {
+        return {
+            error: message,
+            errorCode: code ?? 'TOOL_NOT_FOUND',
+            retryable: false,
+        };
+    }
+    if (status === 400) {
+        return {
+            error: message,
+            errorCode: code ?? 'INVALID_ARGUMENTS',
+            retryable: false,
+        };
+    }
+    return {
+        error: message || `HTTP ${status}`,
+        errorCode: code ?? 'EXECUTION_FAILED',
+        retryable: false,
+    };
+}
+export class HttpToolExecutor {
+    baseUrl;
+    timeout;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/, '');
+        this.timeout = options.timeout ?? 30_000;
+    }
+    async execute(request) {
+        const url = `${this.baseUrl}/api/v1/tools/${encodeURIComponent(request.toolName)}/execute`;
+        const agentCode = request.authContext.agentCode ?? request.authContext.agentId;
+        const correlationId = request.correlationId ?? request.toolCallId;
+        const taskId = request.taskId ?? request.toolCallId;
+        const body = {
+            arguments: request.arguments,
+            caller: {
+                userId: request.authContext.userId,
+                agentId: agentCode,
+                agentCode,
+                delegationToken: request.authContext.delegationToken,
+                taskId,
+                correlationId,
+            },
+        };
+        const headers = {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${request.authContext.delegationToken}`,
+            'X-Agent-Id': agentCode,
+            'X-Agent-Code': agentCode,
+            'X-User-Id': request.authContext.userId,
+            userId: request.authContext.userId,
+            'X-Correlation-Id': correlationId,
+            'X-Task-Id': taskId,
+        };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                let errorBody = null;
+                try {
+                    errorBody = (await response.json());
+                }
+                catch {
+                    errorBody = null;
+                }
+                return {
+                    toolCallId: request.toolCallId,
+                    toolName: request.toolName,
+                    content: '',
+                    success: false,
+                    runtime: 'server',
+                    ...mapGatewayHttpError(response.status, errorBody, response.statusText),
+                };
+            }
+            const raw = (await response.json());
+            const data = raw.data ?? raw;
+            const output = data.output
+                ?? data.content
+                ?? '';
+            const content = typeof output === 'string' ? output : JSON.stringify(output);
+            const success = raw.code === 0 ||
+                raw.code === 'ok' ||
+                raw.success === true ||
+                (raw.success === undefined && raw.code !== 'error');
+            const gatewayError = typeof raw.error === 'object' && raw.error !== null ? raw.error : undefined;
+            return {
+                toolCallId: request.toolCallId,
+                toolName: request.toolName,
+                content,
+                success,
+                error: gatewayError?.message ?? (typeof raw.error === 'string' ? raw.error : undefined),
+                errorCode: gatewayError?.code,
+                retryable: gatewayError?.retryable,
+                runtime: 'server',
+            };
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === 'AbortError') {
+                return {
+                    toolCallId: request.toolCallId,
+                    toolName: request.toolName,
+                    content: '',
+                    success: false,
+                    error: `Request timeout after ${this.timeout}ms`,
+                    errorCode: 'EXECUTION_FAILED',
+                    runtime: 'server',
+                };
+            }
+            const message = error instanceof Error ? error.message : 'Unknown network error';
+            return {
+                toolCallId: request.toolCallId,
+                toolName: request.toolName,
+                content: '',
+                success: false,
+                error: message,
+                errorCode: 'EXECUTION_FAILED',
+                runtime: 'server',
+            };
+        }
+    }
+}

package/dist/tool/index.d.ts

@@ -0,0 +1,18 @@
+export type { AuthContext, ToolCallRequest, ToolCallResult, LLMToolCall, LLMToolCallResponse, IToolExecutor, } from './tool-executor.interface.js';
+export { toLoadedToolMap, type LoadedToolDefinition, type LoadedToolMap, type LoadedToolManifestRef, } from './loaded-tool-definition.js';
+export { ToolOrchestrator } from './tool-orchestrator.js';
+export { HttpToolExecutor, type HttpToolExecutorOptions, } from './http-tool-executor.js';
+export { McpToolExecutor, type McpToolExecutorOptions, } from './mcp-tool-executor.js';
+export { LocalToolExecutor, isLocalPreferredExecution, resolveCodeExecutionFromRequest } from './local-tool-executor.js';
+export { DevMcpExecutor, type DevMcpExecutorOptions, } from './dev-mcp-executor.js';
+export { DevHttpExecutor, buildHttpToolUrl, resolveHttpExecutionFromRequest, type DevHttpExecution, } from './dev-http-executor.js';
+export { DevToolExecutor, type DevToolExecutorOptions } from './dev-tool-executor.js';
+export { MockToolExecutor, type MockToolExecutorOptions, } from './mock-tool-executor.js';
+export { LocalMcpClient, type ILocalMcpClient, type LocalMcpInvokeContext, type LocalMcpInvokeResult, } from './local-mcp-client.js';
+export { fileArtifactFromToolOutput, extractFileReference, resolveFileArtifact, type FileArtifact, } from './file-artifact.js';
+export { ToolExecutionRouter, type DeploymentContext, type ToolExecutionRouterOptions, } from './tool-execution-router.js';
+export { createToolExecutor, EmptyInstallStore, type CreateToolExecutorOptions, } from './create-tool-executor.js';
+export { ToolResultInjector, type ToolMessage, } from './tool-result-injector.js';
+export { ToolEventEmitter } from './tool-event-emitter.js';
+export { ToolConfirmationInterceptor } from './tool-confirmation.js';
+export { SystemPromptBuilder, loadedToolsToApiTools, toLoadedSkillMap, mergeSkillScriptTools, filterLoadedToolsForSkill, type PromptBuildContext, type ApiToolDefinition, type LoadedSkillInfo, type LoadedSkillMap, } from './system-prompt-builder.js';

package/dist/tool/index.js

@@ -0,0 +1,17 @@
+export { toLoadedToolMap, } from './loaded-tool-definition.js';
+export { ToolOrchestrator } from './tool-orchestrator.js';
+export { HttpToolExecutor, } from './http-tool-executor.js';
+export { McpToolExecutor, } from './mcp-tool-executor.js';
+export { LocalToolExecutor, isLocalPreferredExecution, resolveCodeExecutionFromRequest } from './local-tool-executor.js';
+export { DevMcpExecutor, } from './dev-mcp-executor.js';
+export { DevHttpExecutor, buildHttpToolUrl, resolveHttpExecutionFromRequest, } from './dev-http-executor.js';
+export { DevToolExecutor } from './dev-tool-executor.js';
+export { MockToolExecutor, } from './mock-tool-executor.js';
+export { LocalMcpClient, } from './local-mcp-client.js';
+export { fileArtifactFromToolOutput, extractFileReference, resolveFileArtifact, } from './file-artifact.js';
+export { ToolExecutionRouter, } from './tool-execution-router.js';
+export { createToolExecutor, EmptyInstallStore, } from './create-tool-executor.js';
+export { ToolResultInjector, } from './tool-result-injector.js';
+export { ToolEventEmitter } from './tool-event-emitter.js';
+export { ToolConfirmationInterceptor } from './tool-confirmation.js';
+export { SystemPromptBuilder, loadedToolsToApiTools, toLoadedSkillMap, mergeSkillScriptTools, filterLoadedToolsForSkill, } from './system-prompt-builder.js';

package/dist/tool/loaded-tool-definition.d.ts

@@ -0,0 +1,35 @@
+/**
+ * GraphLoader 产出的运行期 Tool 定义
+ *
+ * @see docs/contracts/tool-execution.md §3.2
+ * @see .kiro/specs/04-runtime-core/tasks.md Task 18
+ */
+export type LoadedToolType = 'code' | 'mcp' | 'http';
+export type LoadedToolRuntime = 'local' | 'server' | 'both';
+export type LoadedDataScope = 'user-bound' | 'department-bound' | 'global';
+export interface LoadedToolManifestRef {
+    id: string;
+    name: string;
+    version: string;
+    type: LoadedToolType;
+    description?: string;
+    status?: string;
+    toolRuntime?: LoadedToolRuntime;
+    dataScope?: LoadedDataScope;
+    requireConfirmation?: boolean;
+    /**
+     * MCP/HTTP 出站执行配置（来自 tool.manifest.execution）
+     *
+     * dev 上下文 DevMcpExecutor 消费此字段做直连（stdio / streamable_http / sse）；
+     * server 上下文 gateway 会忽略此字段，改由 foundation-service 侧根据 toolName 分派。
+     */
+    execution?: unknown;
+}
+export interface LoadedToolDefinition {
+    toolId: string;
+    name: string;
+    manifest: LoadedToolManifestRef;
+    inputSchema?: Record<string, unknown>;
+}
+export type LoadedToolMap = Record<string, LoadedToolDefinition>;
+export declare function toLoadedToolMap(definitions: LoadedToolDefinition[]): LoadedToolMap;

package/dist/tool/loaded-tool-definition.js

@@ -0,0 +1,9 @@
+/**
+ * GraphLoader 产出的运行期 Tool 定义
+ *
+ * @see docs/contracts/tool-execution.md §3.2
+ * @see .kiro/specs/04-runtime-core/tasks.md Task 18
+ */
+export function toLoadedToolMap(definitions) {
+    return Object.fromEntries(definitions.map((d) => [d.name, d]));
+}

package/dist/tool/local-mcp-client.d.ts

@@ -0,0 +1,23 @@
+/**
+ * LocalMcpClient — 桌面本地 MCP 调用（stdio / streamable_http）
+ *
+ * mcp-data-service 等上游要求 HTTP 头 `userId`（或 query），再注入 `params._meta.userId`。
+ * 身份优先来自 Runtime ExecutionContext（Token.sub）；manifest headers.userId 作兜底。
+ */
+import type { McpRuntimeExecution } from '@gt-fe/eap-contracts';
+import { type FileArtifact } from './file-artifact.js';
+export interface LocalMcpInvokeContext {
+    /** Platform Token.sub / ExecutionContext.userId */
+    userId?: string | null;
+}
+export interface LocalMcpInvokeResult {
+    content: string;
+    file?: FileArtifact;
+}
+export interface ILocalMcpClient {
+    invoke(execution: McpRuntimeExecution, args: Record<string, unknown>, context?: LocalMcpInvokeContext): Promise<LocalMcpInvokeResult>;
+}
+export declare function formatMcpOutput(result: unknown): string;
+export declare class LocalMcpClient implements ILocalMcpClient {
+    invoke(execution: McpRuntimeExecution, args: Record<string, unknown>, context?: LocalMcpInvokeContext): Promise<LocalMcpInvokeResult>;
+}

package/dist/tool/local-mcp-client.js

@@ -0,0 +1,225 @@
+/**
+ * LocalMcpClient — 桌面本地 MCP 调用（stdio / streamable_http）
+ *
+ * mcp-data-service 等上游要求 HTTP 头 `userId`（或 query），再注入 `params._meta.userId`。
+ * 身份优先来自 Runtime ExecutionContext（Token.sub）；manifest headers.userId 作兜底。
+ */
+import { spawn } from 'node:child_process';
+import readline from 'node:readline';
+import { fileArtifactFromToolOutput, fileBasesFromEnv } from './file-artifact.js';
+export function formatMcpOutput(result) {
+    const r = result;
+    if (r?.structuredContent !== undefined) {
+        return JSON.stringify(redactFileLocators(r.structuredContent));
+    }
+    const text = r?.content?.[0]?.text;
+    if (text) {
+        try {
+            return JSON.stringify(redactFileLocators(JSON.parse(text)));
+        }
+        catch {
+            return text;
+        }
+    }
+    return JSON.stringify(redactFileLocators(result));
+}
+function redactFileLocators(value) {
+    if (Array.isArray(value))
+        return value.map(redactFileLocators);
+    if (!value || typeof value !== 'object')
+        return value;
+    const obj = value;
+    const fileShaped = typeof obj.fileName === 'string'
+        && (typeof obj.url === 'string' || typeof obj.relativePath === 'string');
+    const out = {};
+    for (const [key, child] of Object.entries(obj)) {
+        if (key === 'fileReference' && child && typeof child === 'object' && !Array.isArray(child)) {
+            const ref = { ...child };
+            delete ref.url;
+            delete ref.relativePath;
+            out[key] = ref;
+            continue;
+        }
+        if (fileShaped && (key === 'url' || key === 'relativePath'))
+            continue;
+        out[key] = redactFileLocators(child);
+    }
+    return out;
+}
+function expandEnvRefs(value) {
+    if (!value)
+        return '';
+    return value.replace(/\$\{([A-Z][A-Z0-9_]*)\}/g, (_match, name) => process.env[name] ?? '');
+}
+function resolveUserId(_execution, context) {
+    // 仅用调用期身份（Token/ExecutionContext）；禁止依赖 manifest 静态 headers.userId
+    const fromCtx = context?.userId?.trim();
+    return fromCtx || undefined;
+}
+function withUserMeta(params, userId) {
+    if (!userId)
+        return params;
+    const existingMeta = params._meta && typeof params._meta === 'object' && !Array.isArray(params._meta)
+        ? params._meta
+        : {};
+    return {
+        ...params,
+        _meta: { ...existingMeta, userId: existingMeta.userId ?? userId },
+    };
+}
+function rpcStdio(session, method, params) {
+    const id = session.nextId++;
+    const timeoutMs = session.timeoutMs;
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            session.pending.delete(id);
+            reject(new Error(`MCP RPC timeout: ${method}`));
+        }, timeoutMs);
+        session.pending.set(id, {
+            resolve: (v) => { clearTimeout(timer); resolve(v); },
+            reject: (e) => { clearTimeout(timer); reject(e); },
+        });
+        session.process.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+    });
+}
+async function invokeStdio(execution, args, context) {
+    const { server } = execution;
+    const command = server.command ?? 'node';
+    const spawnArgs = server.args ?? [];
+    const timeoutMs = execution.timeout ?? 30_000;
+    const userId = resolveUserId(execution, context);
+    const child = spawn(command, spawnArgs, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: server.cwd,
+        env: {
+            ...process.env,
+            ...server.env,
+            ...(userId ? { EAP_MCP_USER_ID: userId } : {}),
+        },
+    });
+    const session = {
+        process: child,
+        nextId: 1,
+        pending: new Map(),
+        timeoutMs,
+    };
+    const rl = readline.createInterface({ input: child.stdout });
+    rl.on('line', (line) => {
+        if (!line.trim())
+            return;
+        try {
+            const msg = JSON.parse(line);
+            if (msg.id == null)
+                return;
+            const p = session.pending.get(msg.id);
+            if (!p)
+                return;
+            session.pending.delete(msg.id);
+            if (msg.error)
+                p.reject(new Error(msg.error.message));
+            else
+                p.resolve(msg.result);
+        }
+        catch {
+            /* ignore */
+        }
+    });
+    try {
+        await rpcStdio(session, 'initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'eap-runtime-local', version: '0.1.0' },
+        });
+        const result = await rpcStdio(session, 'tools/call', withUserMeta({ name: execution.toolName, arguments: args }, userId));
+        return toInvokeResult(result, execution.server.env);
+    }
+    finally {
+        child.kill();
+        rl.close();
+    }
+}
+async function invokeStreamableHttp(execution, args, context) {
+    const url = expandEnvRefs(execution.server.url);
+    if (!url) {
+        throw new Error('streamable_http MCP requires server.url');
+    }
+    const timeoutMs = execution.timeout ?? 30_000;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const userId = resolveUserId(execution, context);
+    const rawHeaders = execution.server.headers ?? {};
+    const expandedHeaders = {};
+    for (const [key, value] of Object.entries(rawHeaders)) {
+        expandedHeaders[key] = expandEnvRefs(value);
+    }
+    const headers = {
+        'Content-Type': 'application/json',
+        Accept: 'application/json, text/event-stream',
+        ...expandedHeaders,
+    };
+    // mcp-data-service 认 header `userId`（非 X-User-Id）；Token 上下文可覆盖静态头
+    if (userId) {
+        headers.userId = userId;
+    }
+    const body = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: withUserMeta({ name: execution.toolName, arguments: args }, userId),
+    };
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`MCP HTTP ${response.status}: ${response.statusText}`);
+        }
+        const raw = await response.text();
+        const payload = parseMcpHttpBody(raw);
+        if (payload.error) {
+            throw new Error(payload.error.message ?? 'MCP HTTP error');
+        }
+        return toInvokeResult(payload.result, execution.server.env);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function parseMcpHttpBody(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith('{')) {
+        return JSON.parse(trimmed);
+    }
+    // SSE: 取最后一条 data 行
+    const lines = trimmed.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i].trim();
+        if (line.startsWith('data:')) {
+            const json = line.slice(5).trim();
+            if (json) {
+                return JSON.parse(json);
+            }
+        }
+    }
+    throw new Error('Unrecognized MCP HTTP response');
+}
+export class LocalMcpClient {
+    async invoke(execution, args, context) {
+        if (execution.transport === 'streamable_http') {
+            return invokeStreamableHttp(execution, args, context);
+        }
+        return invokeStdio(execution, args, context);
+    }
+}
+function toInvokeResult(raw, serverEnv) {
+    const structured = (raw && typeof raw === 'object' && !Array.isArray(raw))
+        ? raw.structuredContent
+        : undefined;
+    return {
+        content: formatMcpOutput(raw),
+        file: fileArtifactFromToolOutput(structured ?? raw, fileBasesFromEnv(serverEnv)),
+    };
+}