@gt-fe/eap-runtime 0.0.34 → 0.0.36

package/dist/tool/mcp-tool-exposure.js

@@ -0,0 +1,479 @@
+/**
+ * 每轮发给模型的 function schema 按工具来源决定。
+ *
+ * builtin（execution.source=builtin）以及 type 为 code / http 的工具，始终带完整参数。
+ * type=mcp 且不是 builtin 的，默认不带参数；名称和一行用途写入 system 段 mcp-tools。
+ * 点名，或没点名就调用，都不执行；名字记入本会话，下一次请求带上当前参数后再打外部系统。
+ * 没点名的那句只给模型。员工看模型正文和真正的工具结果（含飞书报错、用户拒绝），不另写未执行。
+ * 新会话不沿用。没有 sessionId 时按 taskId。EAP_DEFER_MCP_TOOLS=0 关闭，恢复为全部 schema 都下发。
+ */
+import { BUILTIN_TOOL_NAMES, isBuiltinToolExecution } from '@gt-fe/eap-contracts';
+import { loadedToolsToApiTools } from './system-prompt-builder.js';
+export const TOOL_SEARCH_NAME = 'tool_search';
+export function deferMcpToolsEnabled(env = process.env) {
+    return env.EAP_DEFER_MCP_TOOLS !== '0';
+}
+export function isDeferredMcpTool(tool) {
+    return tool.manifest.type === 'mcp' && !isBuiltinToolExecution(tool.manifest.execution);
+}
+export function hasDeferredMcp(loadedTools) {
+    return Object.values(loadedTools ?? {}).some(isDeferredMcpTool);
+}
+/** 具名 toolChoice 指向的函数。auto / none / required 没有名字。 */
+export function forcedToolName(toolChoice) {
+    if (!toolChoice || typeof toolChoice !== 'object' || Array.isArray(toolChoice))
+        return undefined;
+    const choice = toolChoice;
+    if (choice.type !== 'function')
+        return undefined;
+    const name = choice.function?.name;
+    return typeof name === 'string' && name.trim() ? name.trim() : undefined;
+}
+/** 有 sessionId 用会话，否则用 taskId。空字符串表示无处可记。 */
+export function exposureScopeId(input) {
+    const sessionId = typeof input.sessionId === 'string' ? input.sessionId.trim() : '';
+    if (sessionId)
+        return sessionId;
+    return typeof input.taskId === 'string' ? input.taskId.trim() : '';
+}
+export function exposedNamesForScope(names, storedScopeId, scopeId) {
+    if (!scopeId || storedScopeId !== scopeId)
+        return [];
+    if (!Array.isArray(names))
+        return [];
+    const out = [];
+    for (const name of names) {
+        if (typeof name === 'string' && name && !out.includes(name))
+            out.push(name);
+    }
+    return out;
+}
+export function mergeExposed(current, additions) {
+    const set = new Set();
+    for (const name of [...current, ...additions]) {
+        if (name)
+            set.add(name);
+    }
+    return [...set].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}
+export function resolveModelToolSurface(input) {
+    if (input.disableTools) {
+        return { apiTools: [], deferred: false };
+    }
+    const defer = deferMcpToolsEnabled(input.env);
+    const all = Object.values(input.loadedTools ?? {});
+    const deferredTools = all.filter(isDeferredMcpTool);
+    if (!defer || deferredTools.length === 0) {
+        return { apiTools: loadedToolsToApiTools(input.loadedTools), deferred: false };
+    }
+    const byName = new Map(all.map((tool) => [tool.name, tool]));
+    const ordered = [];
+    const used = new Set();
+    const push = (tool) => {
+        if (!tool || used.has(tool.name))
+            return;
+        used.add(tool.name);
+        ordered.push(tool);
+    };
+    for (const name of BUILTIN_TOOL_NAMES) {
+        const tool = byName.get(name);
+        if (tool && isBuiltinToolExecution(tool.manifest.execution))
+            push(tool);
+    }
+    const extraBuiltins = all
+        .filter((tool) => isBuiltinToolExecution(tool.manifest.execution) && !used.has(tool.name))
+        .sort(byToolName);
+    for (const tool of extraBuiltins)
+        push(tool);
+    const resident = all
+        .filter((tool) => !isDeferredMcpTool(tool) && !isBuiltinToolExecution(tool.manifest.execution))
+        .sort(byToolName);
+    for (const tool of resident)
+        push(tool);
+    const apiTools = ordered.map(toApiTool);
+    const realSearch = byName.get(TOOL_SEARCH_NAME);
+    if (!realSearch)
+        apiTools.push(toolSearchApiTool());
+    const exposed = new Set(input.exposedNames);
+    if (input.forcedName)
+        exposed.add(input.forcedName);
+    const mcpNames = [...exposed]
+        .filter((name) => {
+        const tool = byName.get(name);
+        return Boolean(tool && isDeferredMcpTool(tool));
+    })
+        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    for (const name of mcpNames) {
+        const tool = byName.get(name);
+        if (tool)
+            apiTools.push(toApiTool(tool));
+    }
+    return {
+        apiTools,
+        mcpToolIndex: buildMcpToolIndex(input.loadedTools),
+        deferred: true,
+    };
+}
+/** 全部推迟中的 MCP：名称 + 现有 description，不截断，不含参数 schema。 */
+export function buildMcpToolIndex(loadedTools) {
+    const rows = Object.values(loadedTools ?? {})
+        .filter(isDeferredMcpTool)
+        .sort(byToolName)
+        .map((tool) => {
+        const desc = oneLine(tool.manifest.description);
+        return `- ${tool.name}${desc ? `：${desc}` : ''}`;
+    });
+    if (rows.length === 0)
+        return undefined;
+    return [
+        '# 可用工具',
+        '下面这些 MCP 工具本轮没有参数说明。先调用 tool_search，把 names 设为工具名。下一次模型调用会带上完整参数，然后再调用。没点名的直接调用不会执行。',
+        rows.join('\n'),
+    ].join('\n');
+}
+export function toolSearchApiTool() {
+    return {
+        type: 'function',
+        function: {
+            name: TOOL_SEARCH_NAME,
+            description: '按名称准备 MCP 工具的完整参数。names：下一次模型调用带上这些工具的当前参数，这一次不执行。query：只返回命中的名称，不带参数，也不加入下一次调用。两个都可以不填，但都不填时不会列出全部工具。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    names: {
+                        description: '要加载参数的 MCP 工具名。可以是字符串、逗号分隔的字符串，或字符串数组。',
+                        anyOf: [
+                            { type: 'array', items: { type: 'string' } },
+                            { type: 'string' },
+                        ],
+                    },
+                    query: {
+                        type: 'string',
+                        description: '不足两个字忽略。名字和搜索词一方包含另一方，或整段搜索词原样出现在用途里时命中。只返回名称，不带参数。',
+                    },
+                },
+            },
+        },
+    };
+}
+const NAME_MISS = '已登记的工具里没有这个名字。MCP 的名字以「可用工具」目录为准，不要告诉用户平台没有这类能力。';
+const QUERY_MISS = '没有命中已登记的 MCP。名字见「可用工具」目录，用 names 点名。';
+export function unloadedCallToolContent(name) {
+    return `未调用 ${name}：参数尚未交给模型，外部系统未执行。请按当前参数重新调用，不要告诉用户已经执行。`;
+}
+export function isUnloadedDeferredCall(tool, sentToolNames) {
+    if (!Array.isArray(sentToolNames) || !tool || !isDeferredMcpTool(tool))
+        return false;
+    return !sentToolNames.includes(tool.name);
+}
+export function runToolSearch(args, loadedTools, alreadyInTools) {
+    const names = parseNames(args?.names);
+    const rawQuery = typeof args?.query === 'string' ? args.query.trim() : '';
+    const query = rawQuery.length >= 2 ? rawQuery : '';
+    const tools = Object.values(loadedTools ?? {});
+    const byName = new Map(tools.map((tool) => [tool.name, tool]));
+    const resident = new Set(alreadyInTools ?? []);
+    if (names.length === 0 && !query) {
+        return {
+            content: '请传入 names（要在下一次模型调用加载参数的 MCP 工具名）或 query（按名称或整段用途匹配）。这次没有列出全部工具。',
+            expose: [],
+        };
+    }
+    const lines = [];
+    const expose = [];
+    for (const name of names) {
+        const tool = byName.get(name);
+        if (!tool || !isDeferredMcpTool(tool)) {
+            if (tool) {
+                lines.push(`${name}：已在本轮 tools 里，可以直接调用。`);
+            }
+            else {
+                lines.push(`${name}：${NAME_MISS}`);
+            }
+            continue;
+        }
+        if (resident.has(name)) {
+            lines.push(`${name}：已在本轮 tools 里，可以直接调用。`);
+            continue;
+        }
+        expose.push(name);
+        lines.push(`${name}：下一次模型调用会带上完整参数。这一次不执行。`);
+    }
+    if (query) {
+        const needle = query.toLowerCase();
+        const matches = tools
+            .filter(isDeferredMcpTool)
+            .filter((tool) => queryMatches(tool, needle))
+            .sort(byToolName);
+        if (matches.length === 0) {
+            lines.push(QUERY_MISS);
+        }
+        else {
+            lines.push(matches.map((tool) => tool.name).join('、'));
+        }
+    }
+    return { content: lines.join('\n'), expose };
+}
+export function partitionToolSearchCalls(calls, loadedTools, env) {
+    const deferActive = deferMcpToolsEnabled(env) && hasDeferredMcp(loadedTools);
+    const intercept = deferActive && !loadedTools?.[TOOL_SEARCH_NAME];
+    if (!intercept) {
+        return { deferActive, intercept: false, search: [], business: calls };
+    }
+    return {
+        deferActive,
+        intercept: true,
+        search: calls.filter((call) => call.name === TOOL_SEARCH_NAME),
+        business: calls.filter((call) => call.name !== TOOL_SEARCH_NAME),
+    };
+}
+/** tool_search 点名，以及本轮调用过的 MCP，记入本会话。直接调用这一次不执行。 */
+export function mcpNamesToExpose(loadedTools, searchExpose, businessNames) {
+    const additions = [...searchExpose];
+    for (const name of businessNames) {
+        const tool = loadedTools?.[name];
+        if (tool && isDeferredMcpTool(tool))
+            additions.push(name);
+    }
+    return additions;
+}
+const NOT_CALLED_LINE = /^未调用 (.+?)：/;
+const USER_REJECTED_LINE = /用户拒绝执行工具 (\S+)/;
+/** 发给模型的历史。不改会话存档。只处理这次 tools 里没有的名字。 */
+export function projectHistoryForModelTools(messages, toolNames) {
+    const dropped = new Map();
+    for (const message of messages) {
+        if (message.role !== 'assistant' || !message.toolCalls?.length)
+            continue;
+        for (const call of message.toolCalls) {
+            if (toolNames.has(call.name))
+                continue;
+            const toolMessage = messages.find((item) => item.role === 'tool' && item.toolCallId === call.id);
+            const body = toolMessage?.content ?? '';
+            dropped.set(call.id, body.startsWith('未调用 ') || !toolMessage
+                ? `未调用 ${call.name}：参数尚未交给模型，外部系统未执行。`
+                : body);
+        }
+    }
+    if (dropped.size === 0)
+        return messages;
+    const out = [];
+    for (const message of messages) {
+        if (message.role === 'tool' && message.toolCallId && dropped.has(message.toolCallId))
+            continue;
+        if (message.role !== 'assistant' || !message.toolCalls?.length) {
+            out.push(message);
+            continue;
+        }
+        const kept = message.toolCalls.filter((call) => !dropped.has(call.id));
+        const notes = message.toolCalls
+            .filter((call) => dropped.has(call.id))
+            .map((call) => dropped.get(call.id) ?? '')
+            .filter((note) => note.length > 0);
+        // 说明放在仍保留的 function call 前面，避免插进 call 和 tool 结果之间。
+        for (const note of notes) {
+            out.push({ role: 'assistant', content: note });
+        }
+        if (kept.length > 0 || message.content.trim()) {
+            const next = { ...message };
+            if (kept.length > 0)
+                next.toolCalls = kept;
+            else
+                delete next.toolCalls;
+            out.push(next);
+        }
+    }
+    return out;
+}
+/**
+ * 员工可见正文。未点名、只报了名，都不改模型的话。
+ * 用户拒绝仍补一行。飞书自己的成功或错误不改。
+ */
+export function correctEmployeeVisibleReply(visible, tools) {
+    const refused = new Map();
+    const executedNames = new Set();
+    for (const tool of tools) {
+        const name = tool.toolName || tool.name || '';
+        const content = typeof tool.content === 'string' ? tool.content : '';
+        if (NOT_CALLED_LINE.test(content) || name === TOOL_SEARCH_NAME)
+            continue;
+        const rejected = USER_REJECTED_LINE.exec(content);
+        if (rejected) {
+            refused.set(rejected[1], `已拒绝执行 ${rejected[1]}，外部系统未调用。`);
+            continue;
+        }
+        if (name)
+            executedNames.add(name);
+    }
+    for (const name of executedNames)
+        refused.delete(name);
+    if (refused.size === 0)
+        return visible;
+    const extra = [...refused.values()].filter((line) => !visible.includes(line));
+    if (extra.length === 0)
+        return visible;
+    return visible.trim() ? `${visible.trim()}\n${extra.join('\n')}` : extra.join('\n');
+}
+/**
+ * 还有未点名的 MCP 时，这段模型正文先攒着，等这条消息落定再决定发不发给员工。
+ * 全部已经在本次 tools 里，或本次没有 tools，仍逐 token 推。
+ */
+export function holdEmployeeTextForUnnamedMcp(loadedTools, sentToolNames) {
+    if (!deferMcpToolsEnabled() || !loadedTools || sentToolNames.length === 0)
+        return false;
+    const sent = new Set(sentToolNames);
+    return Object.values(loadedTools).some((tool) => isDeferredMcpTool(tool) && !sent.has(tool.name));
+}
+/**
+ * 这条模型消息还不能当员工结论：带着没点名的调用，或这一次只点了名。
+ * 没有工具调用时不丢，交给回合结束时的闸门。
+ */
+export function shouldDropUnsettledEmployeeText(calls, loadedTools, sentToolNames) {
+    if (!calls?.length)
+        return false;
+    if (calls.some((call) => isUnloadedDeferredCall(loadedTools?.[call.name], sentToolNames)))
+        return true;
+    return calls.every((call) => call.name === TOOL_SEARCH_NAME);
+}
+function employeePayload(payload) {
+    if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
+        return payload;
+    }
+    return {};
+}
+function employeeToolText(payload) {
+    if (typeof payload.content === 'string' && payload.content)
+        return payload.content;
+    if (typeof payload.error === 'string')
+        return payload.error;
+    return '';
+}
+function isHiddenEmployeeToolEvent(eventType, payload) {
+    if (eventType !== 'tool.called' &&
+        eventType !== 'tool.progress' &&
+        eventType !== 'tool.result' &&
+        eventType !== 'tool.error') {
+        return false;
+    }
+    if (payload.modelOnly === true)
+        return true;
+    if (payload.toolName === TOOL_SEARCH_NAME)
+        return true;
+    return employeeToolText(payload).startsWith('未调用 ');
+}
+/**
+ * 没点名的工具事件和 tool_search 不进员工 SSE。
+ * 判定：`modelOnly`，或工具名是 `tool_search`，或正文以 `未调用 ` 开头。
+ */
+export function takeEmployeeVisibleEvents(eventType, payload) {
+    const body = employeePayload(payload);
+    if (isHiddenEmployeeToolEvent(eventType, body))
+        return [];
+    return [{ type: eventType, payload: body }];
+}
+export function employeeTurnClose(raw, tools) {
+    const visible = correctEmployeeVisibleReply(raw, tools);
+    const base = raw.trim();
+    const next = visible.trim();
+    if (next === base)
+        return { visible, tailChunk: '' };
+    if (!base)
+        return { visible, tailChunk: next };
+    if (next.startsWith(base)) {
+        const rest = next.slice(base.length).replace(/^\n+/, '');
+        return { visible, tailChunk: rest ? `\n${rest}` : '' };
+    }
+    return { visible, tailChunk: `\n${next}` };
+}
+/** 回合结束时要补发的 response.chunk。final 仍是 injected。 */
+export function employeeStreamClose(input) {
+    const close = employeeTurnClose(input.raw, input.tools);
+    const chunks = [];
+    if (close.tailChunk)
+        chunks.push(close.tailChunk);
+    if (input.suffix)
+        chunks.push(input.suffix);
+    return {
+        chunks,
+        persistCorrected: close.tailChunk.length > 0 || Boolean(input.suffix),
+    };
+}
+function messagesSinceLastUser(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message && typeof message === 'object' && message.role === 'user') {
+            return messages.slice(i + 1);
+        }
+    }
+    return messages;
+}
+export function toolFactsSinceLastUser(messages) {
+    const facts = [];
+    for (const message of messagesSinceLastUser(messages)) {
+        if (!message || typeof message !== 'object')
+            continue;
+        const record = message;
+        if (record.role !== 'tool')
+            continue;
+        facts.push({
+            toolName: typeof record.toolName === 'string' ? record.toolName : undefined,
+            content: record.content,
+            success: typeof record.success === 'boolean' ? record.success : undefined,
+        });
+    }
+    return facts;
+}
+/** 本轮最后一条助手正文。图若停在 tool 节点，不用工具正文当员工结论。 */
+export function lastAssistantTextSinceLastUser(messages) {
+    let content = '';
+    for (const message of messagesSinceLastUser(messages)) {
+        if (!message || typeof message !== 'object')
+            continue;
+        const record = message;
+        if (record.role !== 'assistant')
+            continue;
+        content = typeof record.content === 'string' ? record.content : '';
+    }
+    return content;
+}
+function toApiTool(tool) {
+    return {
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.manifest.description,
+            parameters: tool.inputSchema ?? { type: 'object', properties: {} },
+        },
+    };
+}
+function byToolName(a, b) {
+    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+}
+function oneLine(value) {
+    return (value ?? '').replace(/\s+/g, ' ').trim();
+}
+function queryMatches(tool, needle) {
+    const name = tool.name.toLowerCase();
+    const description = (tool.manifest.description ?? '').toLowerCase();
+    return name.includes(needle) || needle.includes(name) || description.includes(needle);
+}
+function parseNames(value) {
+    const raw = [];
+    if (typeof value === 'string')
+        raw.push(value);
+    else if (Array.isArray(value)) {
+        for (const item of value) {
+            if (typeof item === 'string')
+                raw.push(item);
+        }
+    }
+    const out = [];
+    for (const item of raw) {
+        for (const part of item.split(',')) {
+            const name = part.trim();
+            if (name && !out.includes(name))
+                out.push(name);
+        }
+    }
+    return out;
+}

package/dist/tool/system-prompt-builder.d.ts

@@ -16,7 +16,7 @@
  * 基线只走 GraphState.agentSystemPrompt，不写进节点 config。无图时节点无增量。
  * silent 节点不带基线。技能正文不灌 system。
  *
- * 工具只走 API 的 tools 参数（见 loadedToolsToApiTools），不写入 system。
+ * builtin、code、http 的参数走 API tools。推迟下发的 MCP 只把名称和用途写入 system 段 mcp-tools。
  *
  * @see docs/status/module-status-and-backlog.md RT-5
  */
@@ -97,6 +97,11 @@ export interface PromptBuildContext {
     }>;
     /** 已装配 Skill 短目录；单独成段，不并进 Agent 基线 / 节点提示词 */
     skillCatalog?: string;
+    /**
+     * 推迟下发参数的 MCP 工具：名称和现有 description。
+     * 空则省略。不含 JSON Schema。
+     */
+    mcpToolIndex?: string;
 }
 export interface PromptSection {
     id: string;
@@ -127,7 +132,8 @@ export declare function resolveLlmPromptInputs(input: {
  * SystemPromptBuilder — 系统提示词拼接
  *
  * 具名段拼接（无模板引擎）。顺序固定，段标题用于排查。
- * 工具只走 API tools 参数，不进 system。技能短目录进 system（技能不是 function）。
+ * builtin、code、http 的参数走 API tools。推迟下发的 MCP 在段 mcp-tools 写名称和用途。
+ * 技能短目录进 system（技能不是 function）。
  * Agent 基线与节点提示词整段透传，不做 {{ }} 替换。
  */
 export declare class SystemPromptBuilder {
@@ -161,7 +167,8 @@ export declare function buildSkillCatalog(defs: LoadedSkillMap | undefined): str
 /**
  * 将平台的 LoadedToolMap 转为 OpenAI API 的 tools 参数
  *
- * 工具通过 API 的 tools 参数传入 LLM，不嵌入 system prompt。
+ * 工具通过 API 的 tools 参数传入 LLM。
+ * 主图是否把 MCP 放进本轮，见 resolveModelToolSurface。本函数仍按传入的映射原样转换。
  * 可按需传入 skillTools 过滤子集（只暴露当前 Skill 需要的工具）。
  *
  * @param loadedTools - 已装配的工具映射

package/dist/tool/system-prompt-builder.js

@@ -16,7 +16,7 @@
  * 基线只走 GraphState.agentSystemPrompt，不写进节点 config。无图时节点无增量。
  * silent 节点不带基线。技能正文不灌 system。
  *
- * 工具只走 API 的 tools 参数（见 loadedToolsToApiTools），不写入 system。
+ * builtin、code、http 的参数走 API tools。推迟下发的 MCP 只把名称和用途写入 system 段 mcp-tools。
  *
  * @see docs/status/module-status-and-backlog.md RT-5
  */
@@ -31,6 +31,7 @@ const PLATFORM_RULES = `你是运行在企业智能体平台（EAP）上的 AI
 - **调用前说明：** 每次调用前用一句短话告诉用户你在做什么，例如「我来查上个月的销售数据」。
 - **并行：** 无数据依赖的调用必须同一轮同时发起；只有后续依赖前序结果时才分轮。严禁无依赖却串行。
 - **严禁**调用未提供的工具。
+- MCP 工具先用 tool_search 的 names 点名。下一次模型调用带上参数之后再调用。没点名的直接调用不会执行，不要告诉用户已经查到或已经办成。
 - **参数只能来自：**（1）用户明确提供（2）对话里已确认的上下文（3）前序工具返回。缺必填参数就问，禁止猜测。编码、ID、路径、URL 绝对不可凭印象填写。
 - 同一组语义等价参数已经成功返回时，直接用该结果，不要原样重打。
 - 失败时读错误信息再改参数。返回「无权限」则告知用户，不要反复重试。
@@ -50,7 +51,7 @@ const PLATFORM_RULES = `你是运行在企业智能体平台（EAP）上的 AI
 - 数据为空如实说，不编造。一次只问一个澄清问题。
 - 用户说「以上 / 刚才 / 好的 / 需要」且上下文够用时，直接执行，不要再问一遍。
 - 用户问「你可以干什么 / 有什么能力」：用人话概述能帮他做哪类事。点到已有工具和技能的用途即可，不要逐项念内部名称；连通性占位（如 echo-tool）可以不提。
-- 用户问「有哪些工具 / 有哪些技能」：按「可用工具」「可用技能」逐项列出名称与一句话用途。
+- 用户问「有哪些工具 / 有哪些技能」：已在 API tools 中的工具按该清单列出；MCP 工具按「可用工具」目录列出名称与用途；技能按「可用技能」列出。
 - 任务对上某条技能的 description 时直接用（先 read_file 读其 SKILL.md），用户不必先问清单或点名技能。
 
 ## 安全
@@ -119,7 +120,8 @@ export function resolveLlmPromptInputs(input) {
  * SystemPromptBuilder — 系统提示词拼接
  *
  * 具名段拼接（无模板引擎）。顺序固定，段标题用于排查。
- * 工具只走 API tools 参数，不进 system。技能短目录进 system（技能不是 function）。
+ * builtin、code、http 的参数走 API tools。推迟下发的 MCP 在段 mcp-tools 写名称和用途。
+ * 技能短目录进 system（技能不是 function）。
  * Agent 基线与节点提示词整段透传，不做 {{ }} 替换。
  */
 export class SystemPromptBuilder {
@@ -141,6 +143,7 @@ export class SystemPromptBuilder {
             add('user', '当前用户', `## 当前用户\n用户标识：${context.userId.trim()}。用户说「我 / 我的」时使用此标识，不要向用户再要一遍。`);
         }
         add('jail', '文件与命令权限', this.buildJail(context));
+        add('mcp-tools', '可用工具', context.mcpToolIndex);
         add('skills-catalog', '可用技能', context.skillCatalog);
         add('agent', 'Agent 基线', context.agentPrompt);
         add('node', '节点提示词', context.nodePrompt);
@@ -279,7 +282,8 @@ export function buildSkillCatalog(defs) {
 /**
  * 将平台的 LoadedToolMap 转为 OpenAI API 的 tools 参数
  *
- * 工具通过 API 的 tools 参数传入 LLM，不嵌入 system prompt。
+ * 工具通过 API 的 tools 参数传入 LLM。
+ * 主图是否把 MCP 放进本轮，见 resolveModelToolSurface。本函数仍按传入的映射原样转换。
  * 可按需传入 skillTools 过滤子集（只暴露当前 Skill 需要的工具）。
  *
  * @param loadedTools - 已装配的工具映射

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gt-fe/eap-runtime",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "description": "Enterprise Agent Platform — Runtime核心：Graph执行引擎、Task生命周期、Session管理、Checkpoint持久化",
   "type": "module",
   "main": "dist/index.js",
@@ -20,7 +20,7 @@
     "ioredis": "^5.4.0",
     "pg": "^8.13.0",
     "yaml": "^2.6.1",
-    "@gt-fe/eap-contracts": "0.0.17"
+    "@gt-fe/eap-contracts": "0.0.18"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",