@gt-fe/eap-runtime 0.0.13 → 0.0.15

package/dist/token/context-window.js

@@ -0,0 +1,73 @@
+/**
+ * 本轮 prompt 占用的上下文窗：used = 本轮 inputTokens，window = ModelRecord.capabilities.maxContextTokens。
+ * 不是账单合计，也不是 max_tokens。
+ * parts 按本轮 system / messages / tools 字符比例把 used 拆开（无独立 tokenizer）。
+ */
+export function contextWindowUsage(used, window) {
+    return buildContextUsage(used, window);
+}
+export function splitContextUsage(used, sections) {
+    if (!(used > 0))
+        return undefined;
+    const systemChars = Math.max(0, sections.systemChars);
+    const messageChars = Math.max(0, sections.messageChars);
+    const toolChars = Math.max(0, sections.toolChars);
+    const total = systemChars + messageChars + toolChars;
+    if (total <= 0)
+        return undefined;
+    const system = Math.floor((used * systemChars) / total);
+    const tools = Math.floor((used * toolChars) / total);
+    const messages = used - system - tools;
+    return { system, messages, tools };
+}
+export function turnSectionChars(config, messages) {
+    const systemChars = (config.systemPrompt ?? '').length;
+    let messageChars = 0;
+    for (const message of messages) {
+        if (message.content)
+            messageChars += message.content.length;
+        if (message.toolCalls)
+            messageChars += jsonChars(message.toolCalls);
+    }
+    const toolChars = config.tools?.length ? jsonChars(config.tools) : 0;
+    return { systemChars, messageChars, toolChars };
+}
+export function buildContextUsage(used, window, sections) {
+    const safeUsed = typeof used === 'number' && Number.isFinite(used) && used >= 0 ? Math.floor(used) : 0;
+    const win = typeof window === 'number' && Number.isFinite(window) && window > 0
+        ? Math.floor(window)
+        : undefined;
+    const parts = sections ? splitContextUsage(safeUsed, sections) : undefined;
+    if (safeUsed === 0 && win == null && !parts)
+        return undefined;
+    return {
+        used: safeUsed,
+        ...(win != null ? { window: win } : {}),
+        ...(parts ? { parts } : {}),
+    };
+}
+export function pickContextFields(raw) {
+    const out = {};
+    if (typeof raw.used === 'number' && Number.isFinite(raw.used))
+        out.used = raw.used;
+    if (typeof raw.window === 'number' && Number.isFinite(raw.window) && raw.window > 0) {
+        out.window = raw.window;
+    }
+    if (raw.parts && typeof raw.parts === 'object' && !Array.isArray(raw.parts)) {
+        const p = raw.parts;
+        if (typeof p.system === 'number'
+            && typeof p.messages === 'number'
+            && typeof p.tools === 'number') {
+            out.parts = { system: p.system, messages: p.messages, tools: p.tools };
+        }
+    }
+    return out;
+}
+function jsonChars(value) {
+    try {
+        return JSON.stringify(value).length;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/token/index.d.ts

@@ -7,6 +7,7 @@ export { SessionBudgetChecker, SessionBudgetExhaustedError, } from './session-bu
 export type { NodeTokenUsage, TokenBreakdown, TaskTokenSummary, } from './token-stats.service.js';
 export { TokenStatsService } from './token-stats.service.js';
 export type { TokenDetailMode } from './token-detail-mode.js';
+export { contextWindowUsage, buildContextUsage, splitContextUsage, turnSectionChars, pickContextFields, type ContextWindowUsage, type ContextUsageParts, } from './context-window.js';
 export { TokenStatsEmitter } from './token-detail-mode.js';
 export { ContextWindowBudget, createContextBudget, type ContextWindowBudgetConfig, type ContextSource, type SourceAllocation, type BudgetAllocation, DEFAULT_CONTEXT_BUDGET_CONFIG, } from './context-window-budget.js';
 export { CharBasedTokenEstimator, ModelBasedTokenEstimator, createTokenEstimator, type ITokenEstimator, } from './token-estimator.js';

package/dist/token/index.js

@@ -3,6 +3,7 @@ export { PostgresTokenBudgetRepository } from './pg-token-budget.repository.js';
 export { TokenBudgetGuard, TokenBudgetExhaustedError, } from './token-budget-guard.js';
 export { SessionBudgetChecker, SessionBudgetExhaustedError, } from './session-budget-checker.js';
 export { TokenStatsService } from './token-stats.service.js';
+export { contextWindowUsage, buildContextUsage, splitContextUsage, turnSectionChars, pickContextFields, } from './context-window.js';
 export { TokenStatsEmitter } from './token-detail-mode.js';
 // 上下文窗口预算分配
 export { ContextWindowBudget, createContextBudget, DEFAULT_CONTEXT_BUDGET_CONFIG, } from './context-window-budget.js';

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

@@ -9,6 +9,7 @@ export interface DevHttpExecution {
     baseUrl?: string;
     pathTemplate?: string;
     allowedHosts?: string[];
+    header?: Record<string, string>;
     timeout?: number;
 }
 export declare function resolveHttpExecutionFromRequest(request: ToolCallRequest): DevHttpExecution | null;

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

@@ -23,9 +23,20 @@ export function resolveHttpExecutionFromRequest(request) {
         allowedHosts: Array.isArray(e.allowedHosts)
             ? e.allowedHosts.filter((item) => typeof item === 'string')
             : [],
+        header: readHeaderMap(e.header),
         timeout: resolveToolTimeoutSec(e.timeout, DEFAULT_HTTP_TOOL_TIMEOUT_SEC),
     };
 }
+function readHeaderMap(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (typeof value === 'string')
+            out[key] = value;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
 export function buildHttpToolUrl(spec, args) {
     const url = buildSharedHttpToolUrl(spec.baseUrl ?? '', spec.pathTemplate ?? '', args);
     assertHttpHostAllowlisted(url, spec.allowedHosts ?? []);
@@ -54,6 +65,7 @@ export class DevHttpExecutor {
             const timer = setTimeout(() => controller.abort(), toToolTimeoutMs(timeoutSec, DEFAULT_HTTP_TOOL_TIMEOUT_SEC));
             const headers = {
                 Accept: 'application/json, text/plain;q=0.9',
+                ...(spec.header ?? {}),
             };
             const init = { method, headers, signal: controller.signal };
             if (method !== 'GET' && method !== 'HEAD') {

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

@@ -17,13 +17,23 @@
  * @see docs/workflows/local-agent-dev-loop.md
  * @see runtime/src/tool/local-mcp-client.ts
  */
+import { type McpRuntimeExecution } from '@gt-fe/eap-contracts';
 import { type ILocalMcpClient } from './local-mcp-client.js';
-import type { IToolExecutor, ToolCallRequest, ToolCallResult } from './tool-executor.interface.js';
+import type { IToolExecutor, McpListedTool, ToolCallRequest, ToolCallResult } from './tool-executor.interface.js';
 export interface DevMcpExecutorOptions {
     client?: ILocalMcpClient;
 }
 export declare class DevMcpExecutor implements IToolExecutor {
     private readonly client;
+    private readonly listCache;
     constructor(options?: DevMcpExecutorOptions);
     execute(request: ToolCallRequest): Promise<ToolCallResult>;
+    listTools(request: ToolCallRequest): Promise<McpListedTool[]>;
 }
+/**
+ * 把 tool.manifest.execution（McpExecution 结构，transport 可为 stdio/sse/streamable_http）
+ * 规范化为 LocalMcpClient 消费的 McpRuntimeExecution（transport 只支持 stdio/streamable_http）。
+ *
+ * sse 归并到 streamable_http（LocalMcpClient 的 http 分支已能解析 SSE 响应）。
+ */
+export declare function normalizeMcpExecution(raw: unknown, fallbackToolName: string): McpRuntimeExecution | null;

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

@@ -22,6 +22,7 @@ import { isAbortError } from './timeout.js';
 import { LocalMcpClient } from './local-mcp-client.js';
 export class DevMcpExecutor {
     client;
+    listCache = new Map();
     constructor(options = {}) {
         this.client = options.client ?? new LocalMcpClient();
     }
@@ -64,6 +65,28 @@ export class DevMcpExecutor {
             };
         }
     }
+    async listTools(request) {
+        const execution = normalizeExecution(request.execution, request.toolName);
+        if (!execution) {
+            throw new Error(`Dev MCP: tool "${request.toolName}" has no valid mcp execution config (expect manifest.execution.protocol="mcp")`);
+        }
+        const url = execution.server?.url ?? '';
+        const cmd = execution.server?.command ?? '';
+        const args = (execution.server?.args ?? []).join('\0');
+        const key = `${url || `stdio:${cmd}:${args}`}\0${request.authContext?.userId ?? ''}\0${request.authContext?.agentCode ?? ''}`;
+        const cached = this.listCache.get(key);
+        if (cached)
+            return cached;
+        const pending = this.client.list(execution, { userId: request.authContext?.userId });
+        this.listCache.set(key, pending);
+        try {
+            return await pending;
+        }
+        catch (err) {
+            this.listCache.delete(key);
+            throw err;
+        }
+    }
 }
 /**
  * 把 tool.manifest.execution（McpExecution 结构，transport 可为 stdio/sse/streamable_http）
@@ -71,6 +94,9 @@ export class DevMcpExecutor {
  *
  * sse 归并到 streamable_http（LocalMcpClient 的 http 分支已能解析 SSE 响应）。
  */
+export function normalizeMcpExecution(raw, fallbackToolName) {
+    return normalizeExecution(raw, fallbackToolName);
+}
 function normalizeExecution(raw, fallbackToolName) {
     if (!raw || typeof raw !== 'object')
         return null;

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

@@ -10,7 +10,7 @@
  * - 其余 → NOT_CONFIGURED
  */
 import { DevMcpExecutor } from './dev-mcp-executor.js';
-import type { IToolExecutor, ToolCallRequest, ToolCallResult } from './tool-executor.interface.js';
+import type { IToolExecutor, McpListedTool, ToolCallRequest, ToolCallResult } from './tool-executor.interface.js';
 export interface DevToolExecutorOptions {
     mcp?: ConstructorParameters<typeof DevMcpExecutor>[0];
 }
@@ -20,4 +20,5 @@ export declare class DevToolExecutor implements IToolExecutor {
     private readonly local;
     constructor(options?: DevToolExecutorOptions);
     execute(request: ToolCallRequest): Promise<ToolCallResult>;
+    listTools(request: ToolCallRequest): Promise<McpListedTool[]>;
 }

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

@@ -47,6 +47,12 @@ export class DevToolExecutor {
             runtime: 'local',
         };
     }
+    async listTools(request) {
+        if (hasMcpExecution(request.execution)) {
+            return this.mcp.listTools(request);
+        }
+        return [];
+    }
 }
 function hasMcpExecution(raw) {
     if (!raw || typeof raw !== 'object')

package/dist/tool/harness-command.js

@@ -21,7 +21,7 @@ export function commandDialectLines(platform = process.platform) {
     else {
         lines.push('基础命令：当前目录 `pwd`；列目录 `ls`；环境变量 `$VAR`；串命令用 `&&`。');
     }
-    lines.push('解释器：`python`/`python3`、`node`/`nodejs`、`sh`/`bash`（Windows 上 `sh` 需本机有 Git Bash 等）。', '可执行文件：用绝对路径或相对于 cwd（Windows `.exe`/`.bat`/`.cmd`；Unix 二进制需可执行或用 `sh`）。', '`execute_command` 的 cwd 是用户目录。技能包只读。包内任意文件用 `EAP_SKILL_DIR` 加相对路径（不限 `scripts/`）。读到的 SKILL.md 里像脚本的相对路径已展开为绝对路径。不要把 cwd 设成技能目录。相对写出在用户目录。');
+    lines.push('解释器：`python`/`python3`、`node`/`nodejs`、`sh`/`bash`（Windows 上 `sh` 需本机有 Git Bash 等）。', '可执行文件：用绝对路径或相对于 cwd（Windows `.exe`/`.bat`/`.cmd`；Unix 二进制需可执行或用 `sh`）。', '`execute_command` 的 cwd 是用户目录。技能包只读。包内任意文件用 `EAP_SKILL_DIR` 加相对路径（不限 `scripts/`）。读到的 SKILL.md 里本包存在的相对路径已展开为绝对路径。不要把 cwd 设成技能目录。相对写出在用户目录。');
     return lines;
 }
 export function resolveShellSpawn(command, platform = process.platform) {

package/dist/tool/harness-primitives.d.ts

@@ -34,6 +34,13 @@ export declare function resolveJailFromState(state: {
 export declare function resolveJailRoots(options?: HarnessJailOptions): string[];
 /** 路径落在写根外的 extraRoot 时，返回该 extraRoot。 */
 export declare function extraRootContaining(abs: string, extraRoots: string[], workdir: string): string | undefined;
+/**
+ * 相对 read_file：`技能名/文件`、全库唯一命中、显式 skillDir，否则用户目录。
+ */
+export declare function locateSkillRelativeRead(filePath: string, workdir: string | undefined, skillDir: string | undefined, extraRoots?: string[]): {
+    path: string;
+    relativeBase: string | undefined;
+};
 export declare function resolveJailedPath(requested: string, roots: string[], opts?: {
     mustExist?: boolean;
     relativeBase?: string;

package/dist/tool/harness-primitives.js

@@ -8,7 +8,7 @@
  * 开发态可选 overlay：`EAP_LOCAL_SKILLS_DIR` / `EAP_LOCAL_TOOLS_DIR`（只读）。
  */
 import { spawn } from 'node:child_process';
-import { constants as fsConstants, realpathSync } from 'node:fs';
+import { constants as fsConstants, existsSync, realpathSync } from 'node:fs';
 import { mkdir, open, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { BUILTIN_TOOL_SOURCE, DEFAULT_BUILTIN_TIMEOUT_MS, MAX_BUILTIN_TIMEOUT_MS, clampBuiltinTimeout, isBuiltinToolExecution, resolveBuiltinToolsConfig, } from '@gt-fe/eap-contracts';
@@ -252,6 +252,53 @@ function resolveViaExistingAncestor(abs) {
         cur = parent;
     }
 }
+function userReadBase(workdir) {
+    return workdir?.trim()
+        ? (tryRealpath(path.resolve(workdir)) ?? path.resolve(workdir))
+        : undefined;
+}
+function skillPackageRoots(roots) {
+    const out = [];
+    const seen = new Set();
+    for (const root of roots) {
+        const resolved = path.resolve(root);
+        if (seen.has(resolved))
+            continue;
+        seen.add(resolved);
+        if (existsSync(path.join(resolved, 'SKILL.md')) || existsSync(path.join(resolved, 'skill.md'))) {
+            out.push(resolved);
+        }
+    }
+    return out;
+}
+/**
+ * 相对 read_file：`技能名/文件`、全库唯一命中、显式 skillDir，否则用户目录。
+ */
+export function locateSkillRelativeRead(filePath, workdir, skillDir, extraRoots) {
+    const trimmed = filePath.trim();
+    const userBase = userReadBase(workdir);
+    if (!trimmed || path.isAbsolute(trimmed))
+        return { path: trimmed, relativeBase: userBase };
+    const packages = skillPackageRoots([
+        ...(skillDir?.trim() ? [skillDir] : []),
+        ...(extraRoots ?? []),
+    ]);
+    const slash = trimmed.replace(/\\/g, '/');
+    const segs = slash.split('/').filter(Boolean);
+    if (segs.length >= 2) {
+        const hit = packages.find((pkg) => path.basename(pkg) === segs[0]);
+        if (hit)
+            return { path: segs.slice(1).join('/'), relativeBase: hit };
+    }
+    const matches = packages.filter((pkg) => existsSync(path.resolve(pkg, trimmed)));
+    if (matches.length === 1)
+        return { path: trimmed, relativeBase: matches[0] };
+    const skillBase = skillDir?.trim() ? path.resolve(skillDir) : undefined;
+    if (skillBase && existsSync(path.resolve(skillBase, trimmed))) {
+        return { path: trimmed, relativeBase: skillBase };
+    }
+    return { path: trimmed, relativeBase: userBase };
+}
 export function resolveJailedPath(requested, roots, opts) {
     const trimmed = requested.trim();
     if (!trimmed || trimmed.includes('\0')) {
@@ -344,10 +391,10 @@ export class HarnessPrimitiveExecutor {
     async readFile(request) {
         const filePath = String(request.arguments.path ?? request.arguments.file ?? '');
         const workdir = this.workdirFor(request);
-        const relativeBase = workdir ? (tryRealpath(workdir) ?? path.resolve(workdir)) : undefined;
-        const target = resolveJailedPath(filePath, this.rootsFor(request), {
+        const located = locateSkillRelativeRead(filePath, workdir, request.skillDir, this.extraRootsFor(request));
+        const target = resolveJailedPath(located.path, this.rootsFor(request), {
             mustExist: true,
-            relativeBase,
+            relativeBase: located.relativeBase,
         });
         const buf = await readFile(target);
         const config = builtinConfig();
@@ -481,7 +528,7 @@ export class HarnessPrimitiveExecutor {
 }
 export function withHarnessPrimitives(inner, options) {
     const harness = new HarnessPrimitiveExecutor(options);
-    return {
+    const wrapped = {
         execute(request) {
             if (isBuiltinToolExecution(request.execution)) {
                 return harness.execute(request);
@@ -489,4 +536,8 @@ export function withHarnessPrimitives(inner, options) {
             return inner.execute(request);
         },
     };
+    if (typeof inner.listTools === 'function') {
+        wrapped.listTools = (request) => inner.listTools(request);
+    }
+    return wrapped;
 }

package/dist/tool/index.d.ts

@@ -1,4 +1,5 @@
-export type { AuthContext, ToolCallRequest, ToolCallResult, LLMToolCall, LLMToolCallResponse, IToolExecutor, } from './tool-executor.interface.js';
+export type { AuthContext, ToolCallRequest, ToolCallResult, LLMToolCall, LLMToolCallResponse, IToolExecutor, McpListedTool, } from './tool-executor.interface.js';
+export { hydrateMcpTools, isMcpDiscoverStub, needsMcpHydration, parseListedTools, } from './mcp-list.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';

package/dist/tool/index.js

@@ -1,3 +1,4 @@
+export { hydrateMcpTools, isMcpDiscoverStub, needsMcpHydration, parseListedTools, } from './mcp-list.js';
 export { toLoadedToolMap, } from './loaded-tool-definition.js';
 export { ToolOrchestrator } from './tool-orchestrator.js';
 export { HttpToolExecutor, } from './http-tool-executor.js';

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

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

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

@@ -2,12 +2,13 @@
  * LocalMcpClient — 桌面本地 MCP 调用（stdio / streamable_http）
  *
  * mcp-data-service 等上游要求 HTTP 头 `userId`（或 query），再注入 `params._meta.userId`。
- * 身份优先来自 Runtime ExecutionContext（Token.sub）；manifest headers.userId 作兜底。
+ * 身份优先来自 Runtime ExecutionContext（Token.sub）；manifest header.userId 作兜底。
  */
 import { spawn } from 'node:child_process';
 import readline from 'node:readline';
 import { isAbortError, resolveToolTimeoutSec, toToolTimeoutMs, toolTimeoutErrorMessage, } from './timeout.js';
 import { fileArtifactFromToolOutput, fileBasesFromEnv } from './file-artifact.js';
+import { nextListCursor, parseListedTools } from './mcp-list.js';
 export function formatMcpOutput(result) {
     const r = result;
     if (r?.structuredContent !== undefined) {
@@ -53,7 +54,7 @@ function expandEnvRefs(value) {
     return value.replace(/\$\{([A-Z][A-Z0-9_]*)\}/g, (_match, name) => process.env[name] ?? '');
 }
 function resolveUserId(_execution, context) {
-    // 仅用调用期身份（Token/ExecutionContext）；禁止依赖 manifest 静态 headers.userId
+    // 仅用调用期身份（Token/ExecutionContext）；禁止依赖 manifest 静态 header.userId
     const fromCtx = context?.userId?.trim();
     return fromCtx || undefined;
 }
@@ -142,6 +143,61 @@ async function invokeStdio(execution, args, context) {
         rl.close();
     }
 }
+async function listStdio(execution, context) {
+    const { server } = execution;
+    const command = server.command ?? 'node';
+    const spawnArgs = server.args ?? [];
+    const timeoutMs = toToolTimeoutMs(execution.timeout);
+    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' },
+        });
+        return await collectListedTools((params) => rpcStdio(session, 'tools/list', params));
+    }
+    finally {
+        child.kill();
+        rl.close();
+    }
+}
 async function postMcp(url, headers, payload, signal) {
     const response = await fetch(url, {
         method: 'POST',
@@ -171,7 +227,7 @@ async function invokeStreamableHttp(execution, args, context) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
     const userId = resolveUserId(execution, context);
-    const rawHeaders = execution.server.headers ?? {};
+    const rawHeaders = execution.server.header ?? {};
     const expandedHeaders = {};
     for (const [key, value] of Object.entries(rawHeaders)) {
         expandedHeaders[key] = expandEnvRefs(value);
@@ -219,6 +275,61 @@ async function invokeStreamableHttp(execution, args, context) {
         clearTimeout(timer);
     }
 }
+async function listStreamableHttp(execution, context) {
+    const url = expandEnvRefs(execution.server.url);
+    if (!url) {
+        throw new Error('streamable_http MCP requires server.url');
+    }
+    const timeoutSec = resolveToolTimeoutSec(execution.timeout);
+    const timeoutMs = toToolTimeoutMs(timeoutSec);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const userId = resolveUserId(execution, context);
+    const rawHeaders = execution.server.header ?? {};
+    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,
+    };
+    if (userId) {
+        headers.userId = userId;
+    }
+    try {
+        const init = await postMcp(url, headers, {
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'initialize',
+            params: {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: { name: 'eap-runtime-local', version: '0.1.0' },
+            },
+        }, controller.signal);
+        const listHeaders = { ...headers };
+        if (init.sessionId)
+            listHeaders['mcp-session-id'] = init.sessionId;
+        let nextId = 2;
+        return await collectListedTools(async (params) => {
+            const listed = await postMcp(url, listHeaders, { jsonrpc: '2.0', id: nextId++, method: 'tools/list', params }, controller.signal);
+            return listed.body.result;
+        });
+    }
+    catch (err) {
+        if (isAbortError(err)) {
+            const timeoutErr = new Error(toolTimeoutErrorMessage(timeoutSec));
+            timeoutErr.name = 'TimeoutError';
+            throw timeoutErr;
+        }
+        throw err instanceof Error ? err : new Error(String(err));
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 function parseMcpHttpBody(raw) {
     const trimmed = raw.trim();
     if (trimmed.startsWith('{')) {
@@ -244,6 +355,22 @@ export class LocalMcpClient {
         }
         return invokeStdio(execution, args, context);
     }
+    async list(execution, context) {
+        if (execution.transport === 'streamable_http') {
+            return listStreamableHttp(execution, context);
+        }
+        return listStdio(execution, context);
+    }
+}
+async function collectListedTools(rpcList) {
+    const tools = [];
+    let cursor;
+    do {
+        const result = await rpcList(cursor ? { cursor } : {});
+        tools.push(...parseListedTools(result));
+        cursor = nextListCursor(result);
+    } while (cursor);
+    return tools;
 }
 function toInvokeResult(raw, serverEnv) {
     const structured = (raw && typeof raw === 'object' && !Array.isArray(raw))

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

@@ -5,7 +5,7 @@
  * 或 request.execution 带可解析的 code bundlePath+handler，则直接本机执行。
  */
 import type { ILocalToolInstallStore } from '@gt-fe/eap-contracts';
-import type { IToolExecutor, ToolCallRequest, ToolCallResult } from './tool-executor.interface.js';
+import type { IToolExecutor, McpListedTool, ToolCallRequest, ToolCallResult } from './tool-executor.interface.js';
 import { type ILocalMcpClient } from './local-mcp-client.js';
 export interface LocalToolExecutorOptions {
     installStore: ILocalToolInstallStore;
@@ -30,6 +30,7 @@ export declare class LocalToolExecutor implements IToolExecutor {
     private readonly mcpClient;
     constructor(options: LocalToolExecutorOptions);
     execute(request: ToolCallRequest): Promise<ToolCallResult>;
+    listTools(request: ToolCallRequest): Promise<McpListedTool[]>;
     private executeCodeSpec;
     private executeCode;
     private executeMcp;

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

@@ -11,6 +11,7 @@ import { ErrorCodes, resolveReadyInstallByToolName, resolveMcpExecutionFromInsta
 import { isAbortError, toToolTimeoutMs, toolTimeoutErrorMessage } from './timeout.js';
 import { fileArtifactFromToolOutput, fileBasesFromEnv } from './file-artifact.js';
 import { LocalMcpClient } from './local-mcp-client.js';
+import { normalizeMcpExecution } from './dev-mcp-executor.js';
 /**
  * 根据 execution.runtime 解析执行命令：
  * - node（默认）→ process.execPath + [handlerPath]
@@ -171,6 +172,20 @@ export class LocalToolExecutor {
             runtime: 'local',
         };
     }
+    async listTools(request) {
+        const fromRequest = normalizeMcpExecution(request.execution, request.toolName);
+        if (fromRequest) {
+            return this.mcpClient.list(fromRequest, { userId: request.authContext?.userId });
+        }
+        const install = resolveReadyInstallByToolName(this.options.installStore, request.toolName);
+        if (install && install.installStatus === 'ready' && (install.type ?? request.toolType) === 'mcp') {
+            const execution = resolveMcpExecutionFromInstall(install);
+            if (execution) {
+                return this.mcpClient.list(execution, { userId: request.authContext?.userId });
+            }
+        }
+        throw new Error(`MCP tools/list: no mcp execution for "${request.toolName}"`);
+    }
     async executeCodeSpec(request, spec) {
         try {
             const stdout = await runHandler(spec.handlerPath, request.arguments, spec.timeoutMs ?? this.options.timeoutMs ?? 30_000, { runtime: spec.runtime, args: spec.args });