@gt-fe/eap-runtime 0.0.12 → 0.0.14

package/dist/tool/mcp-list.js

@@ -0,0 +1,199 @@
+/**
+ * MCP tools/list 解析、discover stub 判定、hydrate。
+ *
+ * type: mcp 的预装工具集不展开清单 tools[]，先产出 discover stub；
+ * 有 ExecutionContext 后由同一执行器 tools/list，再写入 LLM tools。
+ */
+import { emitRuntimeLog } from '../common/logger.js';
+export function parseListedTools(result) {
+    const tools = result?.tools;
+    if (!Array.isArray(tools))
+        return [];
+    const out = [];
+    for (const raw of tools) {
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            continue;
+        const t = raw;
+        if (typeof t.name !== 'string' || !t.name.trim())
+            continue;
+        const inputSchema = t.inputSchema && typeof t.inputSchema === 'object' && !Array.isArray(t.inputSchema)
+            ? t.inputSchema
+            : undefined;
+        out.push({
+            name: t.name,
+            description: typeof t.description === 'string' ? t.description : undefined,
+            inputSchema,
+        });
+    }
+    return out;
+}
+export function nextListCursor(result) {
+    const cursor = result?.nextCursor;
+    return typeof cursor === 'string' && cursor.trim() ? cursor : undefined;
+}
+export function readMcpDiscoverExecution(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const e = raw;
+    if (e.protocol !== 'mcp' || e.discover !== true)
+        return null;
+    return e;
+}
+export function isMcpDiscoverStub(def) {
+    return def.manifest.type === 'mcp' && readMcpDiscoverExecution(def.manifest.execution) != null;
+}
+export function mcpEndpointKey(execution, fallback = 'gateway') {
+    if (!execution || typeof execution !== 'object' || Array.isArray(execution))
+        return fallback;
+    const e = execution;
+    const server = e.server;
+    if (server && typeof server === 'object') {
+        if (typeof server.url === 'string' && server.url.trim()) {
+            return `http:${server.url.trim()}`;
+        }
+        if (typeof server.command === 'string' && server.command.trim()) {
+            const args = Array.isArray(server.args)
+                ? server.args.map((a) => String(a)).join('\0')
+                : '';
+            return `stdio:${server.command.trim()}:${args}`;
+        }
+    }
+    return fallback;
+}
+export const MCP_LIST_TOOL_NAME = 'tools/list';
+/** 展示用：`tl-data-035/get_dataset_by_code`；无名工具集则只返回工具名。 */
+export function formatToolsetToolName(toolset, toolName) {
+    const set = toolset?.trim() ?? '';
+    const name = toolName.trim() || 'tool';
+    if (!set || set === name)
+        return name;
+    if (name.startsWith(`${set}/`))
+        return name;
+    return `${set}/${name}`;
+}
+/** 从 hydrate 后的 toolId（`toolset:toolName`）取出工具集编码。 */
+export function toolsetCodeFromLoaded(loaded) {
+    if (!loaded)
+        return undefined;
+    const id = loaded.toolId || loaded.manifest?.id || '';
+    const sep = id.indexOf(':');
+    if (sep > 0) {
+        const prefix = id.slice(0, sep);
+        if (prefix && prefix !== loaded.name)
+            return prefix;
+    }
+    return undefined;
+}
+/**
+ * 将 MCP discover stub 替换为 tools/list 结果。
+ * 无 stub 时原样返回（同一引用）。按 endpoint+user+agent 在执行器内缓存 list。
+ * enabledTools 为可选白名单；autoApprove 的子工具 requireConfirmation=false。
+ * 单个 endpoint 的 list 失败只跳过该工具集；全部失败才抛错（错误含工具集名）。
+ */
+export async function hydrateMcpTools(loadedTools, executor, auth) {
+    if (!loadedTools)
+        return loadedTools;
+    const stubs = Object.values(loadedTools).filter(isMcpDiscoverStub);
+    if (stubs.length === 0)
+        return loadedTools;
+    if (typeof executor?.listTools !== 'function') {
+        throw new Error('MCP 工具集需要 tools/list，当前执行器不支持 listTools');
+    }
+    const result = { ...loadedTools };
+    for (const stub of stubs) {
+        delete result[stub.name];
+    }
+    const groups = new Map();
+    for (const stub of stubs) {
+        const key = mcpEndpointKey(stub.manifest.execution);
+        const list = groups.get(key);
+        if (list)
+            list.push(stub);
+        else
+            groups.set(key, [stub]);
+    }
+    const emitted = new Set();
+    const failures = [];
+    for (const [, group] of groups) {
+        const primary = group[0];
+        const endpoint = mcpEndpointKey(primary.manifest.execution, primary.name);
+        let listed;
+        try {
+            listed = await executor.listTools({
+                toolCallId: `mcp-list:${primary.toolId}`,
+                toolName: primary.name,
+                arguments: {},
+                authContext: auth.authContext,
+                correlationId: auth.correlationId,
+                taskId: auth.taskId,
+                toolType: 'mcp',
+                toolRuntime: primary.manifest.toolRuntime,
+                execution: primary.manifest.execution,
+            });
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            const ref = formatToolsetToolName(primary.name, MCP_LIST_TOOL_NAME);
+            const message = `MCP ${ref} 失败 (${endpoint}): ${detail}`;
+            failures.push(message);
+            emitRuntimeLog('warn', 'tool', message, {
+                agentCode: auth.authContext.agentCode,
+                taskId: auth.taskId,
+                correlationId: auth.correlationId,
+            });
+            auth.onListFailure?.({ toolset: primary.name, endpoint, error: detail });
+            continue;
+        }
+        for (const stub of group) {
+            const exec = readMcpDiscoverExecution(stub.manifest.execution);
+            const enabled = exec?.enabledTools;
+            const enabledSet = enabled && enabled.length > 0 ? new Set(enabled) : null;
+            const autoApprove = new Set(exec?.autoApprove ?? []);
+            const picked = enabledSet ? listed.filter((t) => enabledSet.has(t.name)) : listed;
+            for (const tool of picked) {
+                if (emitted.has(tool.name))
+                    continue;
+                emitted.add(tool.name);
+                result[tool.name] = listedToolToDefinition(tool, stub, autoApprove.has(tool.name));
+            }
+        }
+    }
+    if (emitted.size === 0 && failures.length > 0) {
+        throw new Error(failures.join('\n'));
+    }
+    return result;
+}
+function listedToolToDefinition(tool, stub, autoApprove) {
+    const exec = { ...(readMcpDiscoverExecution(stub.manifest.execution) ?? {}) };
+    delete exec.discover;
+    delete exec.enabledTools;
+    delete exec.autoApprove;
+    const rest = exec;
+    return {
+        toolId: `${stub.toolId}:${tool.name}`,
+        name: tool.name,
+        manifest: {
+            id: `${stub.manifest.id}:${tool.name}`,
+            name: tool.name,
+            version: stub.manifest.version,
+            type: 'mcp',
+            status: 'active',
+            description: tool.description,
+            toolRuntime: stub.manifest.toolRuntime,
+            dataScope: stub.manifest.dataScope,
+            requireConfirmation: autoApprove ? false : Boolean(stub.manifest.requireConfirmation),
+            execution: {
+                ...rest,
+                protocol: 'mcp',
+                toolName: tool.name,
+            },
+        },
+        inputSchema: tool.inputSchema ?? { type: 'object', properties: {} },
+    };
+}
+/** 测试与 HITL 续跑：从已 hydrate 的 map 判断是否还要 list */
+export function needsMcpHydration(loadedTools) {
+    if (!loadedTools)
+        return false;
+    return Object.values(loadedTools).some(isMcpDiscoverStub);
+}

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

@@ -3,7 +3,7 @@
  *
  * @see docs/contracts/tool-execution.md §2.0
  */
-import type { IToolExecutor, ToolCallRequest, ToolCallResult } from './tool-executor.interface.js';
+import type { IToolExecutor, McpListedTool, ToolCallRequest, ToolCallResult } from './tool-executor.interface.js';
 export interface McpToolExecutorOptions {
     baseUrl: string;
     timeout?: number;
@@ -16,8 +16,13 @@ export declare class McpToolExecutor implements IToolExecutor {
     private readonly mcpUrl;
     private rpcId;
     private initialized;
+    /** endpoint+user+agent → in-flight / completed tools/list */
+    private readonly listCache;
     constructor(options: McpToolExecutorOptions);
     execute(request: ToolCallRequest): Promise<ToolCallResult>;
+    listTools(request: ToolCallRequest): Promise<McpListedTool[]>;
+    private listAllTools;
+    private rpcResult;
     private ensureInitialized;
     private postRpc;
 }

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

@@ -3,8 +3,9 @@
  *
  * @see docs/contracts/tool-execution.md §2.0
  */
-import { ErrorCodes } from '@gt-fe/eap-contracts';
+import { ErrorCodes } from '@eap/contracts';
 import { abortOrTimeoutMessage, isAbortError } from './timeout.js';
+import { nextListCursor, parseListedTools } from './mcp-list.js';
 function resolveAgentCode(request) {
     return request.authContext.agentCode;
 }
@@ -45,6 +46,8 @@ export class McpToolExecutor {
     mcpUrl;
     rpcId = 1;
     initialized = false;
+    /** endpoint+user+agent → in-flight / completed tools/list */
+    listCache = new Map();
     constructor(options) {
         this.baseUrl = options.baseUrl.replace(/\/+$/, '');
         this.timeout = options.timeout ?? 30_000;
@@ -125,6 +128,55 @@ export class McpToolExecutor {
             };
         }
     }
+    async listTools(request) {
+        const key = `${this.mcpUrl}\0${request.authContext.userId}\0${request.authContext.agentCode}`;
+        const cached = this.listCache.get(key);
+        if (cached)
+            return cached;
+        const pending = this.listAllTools(request);
+        this.listCache.set(key, pending);
+        try {
+            return await pending;
+        }
+        catch (err) {
+            this.listCache.delete(key);
+            throw err;
+        }
+    }
+    async listAllTools(request) {
+        await this.ensureInitialized(request);
+        const tools = [];
+        let cursor;
+        do {
+            const result = await this.rpcResult(request, 'tools/list', cursor ? { cursor } : {});
+            tools.push(...parseListedTools(result));
+            cursor = nextListCursor(result);
+        } while (cursor);
+        return tools;
+    }
+    async rpcResult(request, method, params) {
+        const agentCode = resolveAgentCode(request);
+        const correlationId = request.correlationId ?? request.toolCallId;
+        const id = this.rpcId++;
+        const response = await this.postRpc({ jsonrpc: '2.0', id, method, params }, request, agentCode, correlationId);
+        if (!response.ok) {
+            let body = null;
+            try {
+                body = (await response.json());
+            }
+            catch {
+                body = null;
+            }
+            const mapped = mapMcpError(response.status, body);
+            throw new Error(mapped.error ?? `MCP ${method} failed: HTTP ${response.status}`);
+        }
+        const body = (await response.json());
+        if (body.error) {
+            const mapped = mapMcpError(500, body);
+            throw new Error(mapped.error ?? `MCP ${method} failed`);
+        }
+        return body.result;
+    }
     async ensureInitialized(request) {
         if (this.initialized)
             return;

package/dist/tool/skill-dir-infer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 推断 harness 用的技能包根：命令里的绝对路径、本批/历史 read_file、bind、唯一技能。
+ * 不写 GraphState.activatedSkill。
+ */
+import { type SkillDirRef } from '../graph/adapters/skill-read.js';
+import type { GraphMessage } from '../graph/contracts/executable-graph.js';
+export declare function longestSkillDirInText(text: string, skillDirs: SkillDirRef[]): string | undefined;
+export declare function inferHarnessSkillDir(opts: {
+    command?: string;
+    toolCalls?: Array<{
+        name?: string;
+        arguments?: Record<string, unknown>;
+    }>;
+    messages?: GraphMessage[];
+    skillDirs: SkillDirRef[];
+    activatedSkill?: string | null;
+}): string | undefined;

package/dist/tool/skill-dir-infer.js

@@ -0,0 +1,81 @@
+/**
+ * 推断 harness 用的技能包根：命令里的绝对路径、本批/历史 read_file、bind、唯一技能。
+ * 不写 GraphState.activatedSkill。
+ */
+import { classifySkillRead } from '../graph/adapters/skill-read.js';
+import { normalizeSkillDir } from './skill-script-refs.js';
+export function longestSkillDirInText(text, skillDirs) {
+    const hay = text.replace(/\\/g, '/');
+    let best;
+    for (const dir of skillDirs) {
+        if (!dir.bundlePath)
+            continue;
+        const root = normalizeSkillDir(dir.bundlePath);
+        if (root && hay.includes(root) && (!best || root.length > best.len)) {
+            best = { bundlePath: dir.bundlePath, len: root.length };
+        }
+    }
+    return best?.bundlePath;
+}
+function bundleForSkillId(skillId, skillDirs) {
+    return skillDirs.find((dir) => dir.skillId === skillId)?.bundlePath;
+}
+function lastReadSkillDir(toolCalls, skillDirs) {
+    if (!toolCalls?.length)
+        return undefined;
+    let found;
+    for (const tc of toolCalls) {
+        const hit = classifySkillRead(tc.name ?? '', tc.arguments, skillDirs);
+        if (hit?.skillId) {
+            const bundle = bundleForSkillId(hit.skillId, skillDirs);
+            if (bundle)
+                found = bundle;
+        }
+    }
+    return found;
+}
+function inferFromMessages(messages, skillDirs) {
+    if (!messages?.length)
+        return undefined;
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const msg = messages[i];
+        if (msg.role === 'assistant' && msg.toolCalls?.length) {
+            const found = lastReadSkillDir(msg.toolCalls.map((tc) => ({ name: tc.name, arguments: tc.arguments })), skillDirs);
+            if (found)
+                return found;
+        }
+        if (msg.role === 'tool' && typeof msg.content === 'string') {
+            const tagged = msg.content.match(/技能包根（只读）([^\s。]+)|EAP_SKILL_DIR=([^\s。]+)/);
+            const dir = tagged?.[1] ?? tagged?.[2];
+            if (dir) {
+                const norm = normalizeSkillDir(dir);
+                const hit = skillDirs.find((d) => d.bundlePath && normalizeSkillDir(d.bundlePath) === norm);
+                if (hit?.bundlePath)
+                    return hit.bundlePath;
+            }
+            const fromBody = longestSkillDirInText(msg.content, skillDirs);
+            if (fromBody)
+                return fromBody;
+        }
+    }
+    return undefined;
+}
+export function inferHarnessSkillDir(opts) {
+    const dirs = opts.skillDirs.filter((dir) => Boolean(dir.bundlePath));
+    if (opts.command) {
+        const fromCommand = longestSkillDirInText(opts.command, dirs);
+        if (fromCommand)
+            return fromCommand;
+    }
+    const fromBatch = lastReadSkillDir(opts.toolCalls, dirs);
+    if (fromBatch)
+        return fromBatch;
+    const fromHistory = inferFromMessages(opts.messages, dirs);
+    if (fromHistory)
+        return fromHistory;
+    if (dirs.length === 1)
+        return dirs[0].bundlePath;
+    if (opts.activatedSkill)
+        return bundleForSkillId(opts.activatedSkill, dirs);
+    return undefined;
+}

package/dist/tool/skill-script-refs.d.ts

@@ -6,15 +6,8 @@
  */
 export declare const EAP_SKILL_DIR_ENV = "EAP_SKILL_DIR";
 export interface ExpandSkillRefsOptions {
-    platform?: string;
     exists?: (absPath: string) => boolean;
 }
 export declare function normalizeSkillDir(skillDir: string): string;
-export declare function skillEnvRef(platform?: string): string;
-/**
- * 包内相对脚本路径 → 技能目录绝对路径。
- * 带目录或 `./` 的（`bin/foo.py`、`./main.py`、`scripts/a.py`）一律展开。
- * 根上的裸文件名（`main.py`）仅当包内确实有该文件才展开，以免改写「写到用户目录再跑」的例子。
- */
-export declare function expandSkillScriptRefs(body: string, skillDir: string, platformOrOpts?: string | ExpandSkillRefsOptions): string;
+export declare function expandSkillScriptRefs(body: string, skillDir: string, opts?: ExpandSkillRefsOptions): string;
 export declare function isSkillEntryFile(filePath: string): boolean;

package/dist/tool/skill-script-refs.js

@@ -13,14 +13,6 @@ const RELATIVE_CODE_PATH = new RegExp(`(^|[^$\\w./\\\\:%])(\\.\\/)?((?:[\\w.-]+[
 export function normalizeSkillDir(skillDir) {
     return skillDir.replace(/\\/g, '/').replace(/\/+$/, '');
 }
-export function skillEnvRef(platform = process.platform) {
-    return platform === 'win32' ? `%${EAP_SKILL_DIR_ENV}%` : `$${EAP_SKILL_DIR_ENV}`;
-}
-function asOptions(platformOrOpts) {
-    if (typeof platformOrOpts === 'string')
-        return { platform: platformOrOpts };
-    return platformOrOpts ?? {};
-}
 function defaultExists(absPath) {
     try {
         return existsSync(absPath);
@@ -34,12 +26,37 @@ function defaultExists(absPath) {
  * 带目录或 `./` 的（`bin/foo.py`、`./main.py`、`scripts/a.py`）一律展开。
  * 根上的裸文件名（`main.py`）仅当包内确实有该文件才展开，以免改写「写到用户目录再跑」的例子。
  */
-export function expandSkillScriptRefs(body, skillDir, platformOrOpts) {
-    const opts = asOptions(platformOrOpts);
-    const platform = opts.platform ?? process.platform;
-    const exists = opts.exists ?? defaultExists;
+function resolvePackageRelativePath(rel, skillDir, exists = defaultExists) {
+    const raw = rel.trim();
+    if (!raw || raw.startsWith('#') || raw.includes('://'))
+        return undefined;
+    if (path.isAbsolute(raw) || /^[A-Za-z]:[\\/]/.test(raw))
+        return undefined;
+    if (raw.startsWith('$') || raw.startsWith('%'))
+        return undefined;
+    const relNorm = raw.replace(/\\/g, '/').replace(/^\.\//, '');
+    if (!relNorm || !/\.[A-Za-z0-9]{1,8}$/.test(relNorm))
+        return undefined;
+    const abs = path.resolve(skillDir, relNorm);
+    if (!exists(abs))
+        return undefined;
+    return normalizeSkillDir(abs);
+}
+function expandPackageFileRefs(body, skillDir, exists) {
+    return body.replace(/\]\(([^)]+)\)|`([^`\n]+)`/g, (full, linkDest, tickDest) => {
+        const raw = (linkDest ?? tickDest ?? '').trim();
+        const abs = resolvePackageRelativePath(raw, skillDir, exists);
+        if (!abs)
+            return full;
+        if (linkDest != null)
+            return `](${abs})`;
+        return `\`${abs}\``;
+    });
+}
+export function expandSkillScriptRefs(body, skillDir, opts) {
+    const exists = opts?.exists ?? defaultExists;
     const dir = normalizeSkillDir(skillDir);
-    const expanded = body.replace(RELATIVE_CODE_PATH, (full, prefix, dotSlash, rel) => {
+    let expanded = body.replace(RELATIVE_CODE_PATH, (full, prefix, dotSlash, rel) => {
         const relNorm = rel.replace(/\\/g, '/');
         const packageRelative = Boolean(dotSlash) || relNorm.includes('/');
         if (!packageRelative && !exists(path.join(skillDir, relNorm))) {
@@ -47,15 +64,10 @@ export function expandSkillScriptRefs(body, skillDir, platformOrOpts) {
         }
         return `${prefix}${dir}/${relNorm}`;
     });
-    const envRef = skillEnvRef(platform);
-    const envPath = platform === 'win32' ? `${envRef}\\<相对路径>` : `${envRef}/<相对路径>`;
-    const note = `技能目录（只读）环境变量 ${EAP_SKILL_DIR_ENV}=${dir}。` +
-        `包内任意文件用 ${envPath}（不限 scripts/）。` +
-        `读入正文里像包内脚本的相对路径已展开为绝对路径。` +
-        `当前工作目录是用户目录，相对路径写出在用户目录。\n\n`;
+    expanded = expandPackageFileRefs(expanded, skillDir, exists);
     if (body.includes(`${EAP_SKILL_DIR_ENV}=`))
         return expanded;
-    return note + expanded;
+    return `技能包根（只读）${dir}。\n\n` + expanded;
 }
 export function isSkillEntryFile(filePath) {
     return /(^|[\\/])(SKILL\.md|skill\.md)$/i.test(filePath);

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

@@ -7,12 +7,15 @@
  * ```
  * [平台规则常量]          ← 代码内置，安全约束 + 行为准则（最高优先级）
  * [当前时间]              ← 运行时动态注入（自然周等时间规则的判定基准）
- * [Agent 身份]            ← agentName / agentCode
+ * [Agent 身份]            ← agentName / agentCode（目录身份，不是 prompts.system）
  * [可用工具短目录]        ← 名称 + 一句话用途；完整 schema 仍走 API tools
- * [开发者提示词]          ← Graph LLM 节点 config.systemPrompt，平台透传
- *                           （Registry 无内嵌 Graph 的兜底路径读 agent.manifest.json prompts.system）
+ * [Agent 基线]            ← agent.manifest.json prompts.system；非 silent LLM
+ * [节点提示词]            ← Graph LLM 节点 config.systemPrompt / systemPromptFile
  * ```
  *
+ * 基线只走 GraphState.agentSystemPrompt，不写进节点 config。无图时节点无增量。
+ * silent 节点不带基线。技能正文不灌 system。
+ *
  * 工具 schema 走 API 的 tools 参数（见 loadedToolsToApiTools）；system 短目录给模型发现用，不是对用户报菜名。
  *
  * @see docs/status/module-status-and-backlog.md RT-5
@@ -37,6 +40,10 @@ export interface LoadedSkillInfo {
     workflow?: import('../graph/contracts/executable-graph.js').GraphDSL;
     /** 子图入口可选上下文；Harness 主路径不灌 system */
     prompt?: string;
+    /**
+     * 已废弃：Skill 不再声明/装配 Tool。
+     * 工具只来自 Agent `toolsets`；本字段忽略。
+     */
     toolsets?: Array<string | {
         name?: string;
         version?: string;
@@ -51,24 +58,24 @@ export interface LoadedSkillInfo {
 export type LoadedSkillMap = Record<string, LoadedSkillInfo>;
 export declare function toLoadedSkillMap(skills: LoadedSkillInfo[] | undefined): LoadedSkillMap | undefined;
 /**
- * 按 Skill.toolsets 收窄工具集（子图用）。
- * - 无 toolsets / 空数组：不收窄
- * - string / name：精确匹配工具名
- * - code + enabled：仅白名单子工具
- * - code 无 enabled：匹配 toolId 前缀 `<code>:` 或 id 等于 code
- * - 始终保留 Harness 原语
+ * 进入 Skill 子图时的工具集。
+ * 工具只来自 Agent 装配；不读 Skill `toolsets` / `toolRefs` / SKILL.md `allowed-tools`。
  */
-export declare function filterLoadedToolsForSkill(loadedTools: LoadedToolMap | undefined, skill: LoadedSkillInfo | undefined): LoadedToolMap | undefined;
+export declare function filterLoadedToolsForSkill(loadedTools: LoadedToolMap | undefined, _skill?: LoadedSkillInfo): LoadedToolMap | undefined;
 /**
  * 提示词构建上下文
  */
 export interface PromptBuildContext {
     /**
-     * 开发者编写的系统提示词。
-     * 来源：Graph LLM 节点 config.systemPrompt（主路径）；
-     * Registry 无内嵌 Graph 的兜底路径为 agent.manifest.json prompts.system。
+     * Agent 基线系统提示词（manifest.prompts.system）。
+     * 非 silent LLM 才传入；空则省略本段。
+     */
+    agentPrompt?: string;
+    /**
+     * 本节点增量。来源：Graph LLM 节点 config.systemPrompt / systemPromptFile。
+     * 空或空白则省略。不再承担 Agent 基线。
      */
-    developerPrompt?: string;
+    nodePrompt?: string;
     /** Agent 名称 */
     agentName?: string;
     /** Agent 代码标识 */
@@ -88,7 +95,7 @@ export interface PromptBuildContext {
         bundlePath: string;
         entryFile?: string;
     }>;
-    /** 已装配 Skill 短目录；单独成段，不并进开发者提示词 */
+    /** 已装配 Skill 短目录；单独成段，不并进 Agent 基线 / 节点提示词 */
     skillCatalog?: string;
     /** 已装配工具短目录（名称 + 用途）；schema 仍走 API tools */
     toolCatalog?: string;
@@ -102,12 +109,24 @@ export interface AssembledSystemPrompt {
     text: string;
     sections: PromptSection[];
 }
+/**
+ * 非 silent LLM 才带 Agent 基线；节点提示词空则省略。
+ * silent 只保留节点增量（选技能 / JSON）。
+ */
+export declare function resolveLlmPromptInputs(input: {
+    silent: boolean;
+    agentSystemPrompt?: unknown;
+    nodePrompt?: unknown;
+}): {
+    agentPrompt?: string;
+    nodePrompt?: string;
+};
 /**
  * SystemPromptBuilder — 系统提示词拼接
  *
  * 具名段拼接（无模板引擎）。顺序固定，段标题用于排查。
  * 工具短目录进 system；完整 schema 走 API tools 参数。
- * 开发者提示词整段透传，不做 {{ }} 替换。
+ * Agent 基线与节点提示词整段透传，不做 {{ }} 替换。
  */
 export declare class SystemPromptBuilder {
     /**