@steerable/agent-shell 0.6.51 → 0.6.53

package/dist/local-backend/task-service.js

@@ -32,6 +32,7 @@ import { buildExecSandbox } from '../sidecar/exec-sandbox.js';
 import { resolveTurnApproval } from '../host-tools-runtime.js';
 import { readSidecarHistoryEntries, timelineFromHistoryEntries, } from './task-process.js';
 import { appendTimelineDelta, syncTimelineTools, } from './turn-timeline.js';
+import { presentToolCall } from '../tool-presentation.js';
 /** 任务回合的系统提示词：自包含、汇报结果、不假装执行。 */
 function buildTaskSystemPrompt(input) {
     const lines = [
@@ -278,7 +279,11 @@ export class TaskService {
             (this.deps.resolveChatWorkspaceRoot
                 ? await this.deps.resolveChatWorkspaceRoot(chatId)
                 : null);
-        const execSandbox = buildExecSandbox(fenceRoot ? [fenceRoot] : []);
+        const writableRoots = [
+            ...(fenceRoot ? [fenceRoot] : []),
+            ...(project?.sourceFolders ?? []),
+        ];
+        const execSandbox = buildExecSandbox(writableRoots);
         const approval = resolveTurnApproval();
         // depth-1：任务回合没有 task_run（不能再派生任务），其余工具面与
         // 普通回合一致；task_status / task_result 保留（任务可以自查/互查）。
@@ -332,7 +337,7 @@ export class TaskService {
                     },
                 }),
                 execSandbox,
-                approval,
+                approval: approval ? { ...approval, writableRoots } : undefined,
                 // 与主对话同一套内置画像（explore/research/coder）——任务回合的
                 // 子代理编排语义不分叉。
                 subagent: builtinSubagentParam(),
@@ -341,6 +346,8 @@ export class TaskService {
                 askUser: false,
                 onStreamId: (streamId) => {
                     entry.streamId = streamId;
+                    if (entry.killed)
+                        void supervisor.cancelChat(streamId);
                 },
                 onText: (delta) => {
                     answer += delta;
@@ -356,6 +363,7 @@ export class TaskService {
                         id: call.id,
                         tool: call.tool,
                         arguments: call.arguments,
+                        view: presentToolCall(call.tool, call.arguments),
                         threw: false,
                     });
                     syncTimelineTools(entry.timeline, entry.actions);
@@ -369,6 +377,7 @@ export class TaskService {
                         id: action.id,
                         tool: action.tool,
                         arguments: action.arguments,
+                        view: presentToolCall(action.tool, action.arguments, action.result),
                         result: action.result,
                         success: action.success,
                         error: action.error,
@@ -398,6 +407,10 @@ export class TaskService {
                 traceId = failureTraceId;
             }
         }
+        if (entry.killed) {
+            status = 'failed';
+            error = entry.killReason || 'killed by job_kill';
+        }
         await this.store.updateTask(taskId, {
             status,
             answer: answer.trim() || null,
@@ -430,6 +443,38 @@ export class TaskService {
             tasks: tasks.map((t) => this.toModelView(t)),
         };
     }
+    /**
+     * job_kill：结束 running 或 blocked 任务。running 先打标记再取消流，
+     * 终态回写看到标记后保持 failed，避免流的正常完成把杀死盖掉。
+     */
+    async kill(chatId, taskId, reason) {
+        const task = await this.store.getTask(taskId);
+        if (!task || task.chatId !== chatId) {
+            return { success: false, error: `任务不存在：${taskId}` };
+        }
+        if (task.status === 'completed' || task.status === 'failed') {
+            return { success: false, error: `任务已终态（${task.status}），不能再结束。` };
+        }
+        const note = reason?.trim() || 'killed by job_kill';
+        const entry = this.running.get(taskId);
+        if (entry) {
+            entry.killed = true;
+            entry.killReason = note;
+        }
+        if (!entry || task.status === 'blocked') {
+            await this.store.updateTask(taskId, { status: 'failed', error: note });
+            this.deps.broadcast?.('task-updated', { chatId, taskId });
+            if (task.status === 'blocked')
+                await this.maybeUnblock(chatId);
+            return { success: true, job_id: taskId, status: 'failed', killed: true };
+        }
+        const getSupervisor = this.deps.getSupervisor ?? getSidecarSupervisor;
+        const supervisor = getSupervisor();
+        if (entry.streamId && supervisor) {
+            await supervisor.cancelChat(entry.streamId);
+        }
+        return { success: true, job_id: taskId, status: 'failed', killed: true };
+    }
     /** task_result 工具：取终态任务的完整结果。 */
     async result(chatId, taskId) {
         const task = await this.store.getTask(taskId);

package/dist/local-executor.d.ts

@@ -1,3 +1,4 @@
+import { type ExecDecisionName, type ExecPolicy, type ShellEndpoint, type ShellProcessBackend } from './shell-exec.js';
 import { type ApplyEditsResult, type EditOp } from './local-edit.js';
 export declare function getWineCommand(): string | null;
 export declare function rewriteExeCommandIfNeeded(command: string): string;
@@ -8,6 +9,10 @@ export interface LocalExecRequest {
     timeout?: number;
     env?: Record<string, string>;
     shell?: ShellType;
+    /** 在伪终端里跑。缺省走管道，调用方要终端语义时显式打开。 */
+    pty?: boolean;
+    /** 用户已经批准一次 prompt 决定。不能放过 forbidden。 */
+    execApproval?: 'allow';
 }
 export interface LocalExecResult {
     success: boolean;
@@ -25,6 +30,14 @@ export interface LocalExecResult {
      * "程序已启动并在运行" 对启动类命令就是成功，不能让 LLM 当失败重试。
      */
     stillRunning?: boolean;
+    /** 前缀策略的决定。forbidden 不启动进程；prompt 在批准前也不启动。 */
+    execDecision?: ExecDecisionName;
+    /** prompt 时为 true，让模型把决定交给用户而不是改写命令重试。 */
+    needsFollowup?: boolean;
+    /** 这次命令跑在本机还是 SSH 对端。 */
+    transport?: 'local' | 'ssh';
+    /** 这次启动是否分配了伪终端。 */
+    pty?: boolean;
 }
 export interface LocalFileReadRequest {
     path: string;
@@ -159,8 +172,20 @@ export declare function isGuiLaunchCommand(command: string): boolean;
  * 字符串/相对路径判断，不碰 fs，方便 ToolRouter 与 LocalExecutor 共用。
  */
 export declare function isPathWithinRoot(resolvedPath: string, resolvedRoot: string): boolean;
+/** `~` 展开后 resolve。围栏比较前路径与根都要过这一步。 */
+export declare function expandFencePath(inputPath: string): string;
+/**
+ * 可写根：项目家目录（或对话工作区）加上额外可写根（源文件夹）。
+ * 每个根都包含它自己和全部子目录。空列表表示不设围栏。
+ */
+export declare function writableFenceRoots(projectRoot?: string | null, additionalWriteRoots?: string[] | null): string[];
 /** 越界错误消息（给模型看，引导它把操作收回项目目录内）。 */
 export declare function buildProjectRootViolation(resolvedPath: string, resolvedRoot: string): string;
+/**
+ * 路径不在任一可写根（含其子目录）内时返回给模型的错误；在围栏内或未设围栏时返回 null。
+ * `resolvedPath` 与 `roots` 都应已 resolve。
+ */
+export declare function writableFenceViolation(resolvedPath: string, roots: string[]): string | null;
 export interface CommandSafetyConfigPayload {
     disabledPatternIds: string[];
     customPatterns: Array<{
@@ -196,7 +221,14 @@ export declare class LocalExecutor {
      * 重灌此集合（与框架一致：resume 只重建 version 证据，门退化为 CAS）。
      */
     private readonly partialReadPaths;
+    private execPolicy;
+    private shellEndpoint;
+    private shellBackend;
     constructor(maxOutputBytes?: number, applyEditsFn?: ApplyEditsFn);
+    setExecPolicy(policy: ExecPolicy): void;
+    setShellEndpoint(endpoint: ShellEndpoint): void;
+    /** 测试和嵌入方替换真正的进程启动。缺省用本机管道或 PTY。 */
+    setShellBackend(backend: ShellProcessBackend | null): void;
     updateSafetyConfig(config: CommandSafetyConfigPayload): void;
     /**
      * P2b：会话恢复时重灌 read-before-write 证据。sidecar 扫描持久记录里的
@@ -215,14 +247,16 @@ export declare class LocalExecutor {
         osArch: string;
     };
     executeShell(request: LocalExecRequest): Promise<LocalExecResult>;
+    private holdForExecPolicy;
+    private runPlannedShell;
     readLocalFile(request: LocalFileReadRequest, projectRoot?: string | null, additionalReadRoots?: string[] | null): Promise<LocalFileReadResult>;
-    writeLocalFile(request: LocalFileWriteRequest, projectRoot?: string | null): Promise<LocalFileWriteResult>;
+    writeLocalFile(request: LocalFileWriteRequest, projectRoot?: string | null, additionalWriteRoots?: string[] | null): Promise<LocalFileWriteResult>;
     /**
      * local_edit_file 的实现（W6-1）：结构化批量编辑。先按 expectedVersion 做
      * read-before-write 冲突检测，再在原文上做三级模糊定位 + 逆序替换，最后
      * 原子落盘。返回新版本令牌与统一 diff。
      */
-    editLocalFile(request: LocalFileEditRequest, projectRoot?: string | null): Promise<LocalFileEditResult>;
+    editLocalFile(request: LocalFileEditRequest, projectRoot?: string | null, additionalWriteRoots?: string[] | null): Promise<LocalFileEditResult>;
     /**
      * read-before-write 冲突检测：当前内容版本与调用方期望不一致时返回错误
      * 消息（引导重新读取），一致返回 null。文件不存在且期望存在也算冲突，

package/dist/local-executor.js

@@ -7,6 +7,8 @@ import { spawn, execSync } from 'child_process';
 import log from 'electron-log';
 import { constants as fsConstants } from 'fs';
 import { adaptCommandForPowerShell } from './shell-adapt.js';
+import { evaluateExecPolicy, planSshArgv, } from './shell-exec.js';
+import { nodeShellBackend } from './shell-process.js';
 import { applyEdits, EditError } from './local-edit.js';
 // `he` ships as CommonJS and does not expose ESM named exports, so we have to
 // take the default import and destructure at runtime in this ESM module.
@@ -180,11 +182,53 @@ export function isPathWithinRoot(resolvedPath, resolvedRoot) {
     const rel = path.relative(resolvedRoot, resolvedPath);
     return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
 }
+/** `~` 展开后 resolve。围栏比较前路径与根都要过这一步。 */
+export function expandFencePath(inputPath) {
+    const expanded = inputPath.startsWith('~')
+        ? path.join(os.homedir(), inputPath.slice(1))
+        : inputPath;
+    return path.resolve(expanded);
+}
+/**
+ * 可写根：项目家目录（或对话工作区）加上额外可写根（源文件夹）。
+ * 每个根都包含它自己和全部子目录。空列表表示不设围栏。
+ */
+export function writableFenceRoots(projectRoot, additionalWriteRoots) {
+    const roots = [];
+    const push = (raw) => {
+        if (!raw)
+            return;
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return;
+        const resolved = expandFencePath(trimmed);
+        if (!roots.includes(resolved))
+            roots.push(resolved);
+    };
+    push(projectRoot);
+    for (const extra of additionalWriteRoots ?? [])
+        push(extra);
+    return roots;
+}
 /** 越界错误消息（给模型看，引导它把操作收回项目目录内）。 */
 export function buildProjectRootViolation(resolvedPath, resolvedRoot) {
     return (`路径越界：${resolvedPath} 不在当前对话绑定的项目目录 ${resolvedRoot} 内。` +
-        `项目模式下文件操作被限制在项目目录中——请改用项目内的相对/绝对路径；` +
-        `如确需访问目录外文件，请告知用户该限制并请其把文件放进项目目录。`);
+        `项目模式下文件操作被限制在项目目录及其子目录中——请改用项目内的相对/绝对路径；` +
+        `如确需访问目录外文件，请告知用户该限制并请其把目录附加为源文件夹。`);
+}
+/**
+ * 路径不在任一可写根（含其子目录）内时返回给模型的错误；在围栏内或未设围栏时返回 null。
+ * `resolvedPath` 与 `roots` 都应已 resolve。
+ */
+export function writableFenceViolation(resolvedPath, roots) {
+    if (roots.length === 0)
+        return null;
+    if (roots.some((root) => isPathWithinRoot(resolvedPath, root)))
+        return null;
+    if (roots.length === 1)
+        return buildProjectRootViolation(resolvedPath, roots[0]);
+    return (`路径越界：${resolvedPath} 不在可写目录内（${roots.join('、')}）。` +
+        `可写范围是这些目录及其子目录。请改用其中的路径。`);
 }
 const BUILTIN_DANGEROUS = [
     { id: 'rm_rf_root', pattern: 'rm\\s+-rf\\s+\\/(?:\\s|$)', platform: 'unix' },
@@ -199,6 +243,16 @@ const BUILTIN_DANGEROUS = [
     { id: 'win_del_force', pattern: '\\bdel\\s+\\/f\\s+\\/s\\s+\\/q\\s+[a-z]:\\\\', platform: 'windows' },
     { id: 'win_rd_force', pattern: '\\brd\\s+\\/s\\s+\\/q\\s+[a-z]:\\\\', platform: 'windows' },
 ];
+function stringEnv(extra) {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (typeof value === 'string')
+            env[key] = value;
+    }
+    if (extra)
+        Object.assign(env, extra);
+    return env;
+}
 function toWslPath(input) {
     const normalized = input.replace(/\\/g, '/');
     const winDriveMatch = normalized.match(/^([A-Za-z]):\/(.*)$/);
@@ -231,11 +285,24 @@ export class LocalExecutor {
      * 重灌此集合（与框架一致：resume 只重建 version 证据，门退化为 CAS）。
      */
     partialReadPaths = new Set();
+    execPolicy = { rules: [] };
+    shellEndpoint = { kind: 'local' };
+    shellBackend = null;
     constructor(maxOutputBytes = DEFAULT_MAX_OUTPUT_BYTES, applyEditsFn = applyEdits) {
         this.maxOutputBytes = maxOutputBytes;
         this.applyEditsFn = applyEditsFn;
         this.defaultShell = this.computeDefaultShell();
     }
+    setExecPolicy(policy) {
+        this.execPolicy = policy;
+    }
+    setShellEndpoint(endpoint) {
+        this.shellEndpoint = endpoint;
+    }
+    /** 测试和嵌入方替换真正的进程启动。缺省用本机管道或 PTY。 */
+    setShellBackend(backend) {
+        this.shellBackend = backend;
+    }
     updateSafetyConfig(config) {
         const disabled = new Set(config.disabledPatternIds);
         const isWin = process.platform === 'win32';
@@ -313,8 +380,12 @@ export class LocalExecutor {
             if (dangerousReason) {
                 return { success: false, error: `Blocked dangerous command: ${dangerousReason}` };
             }
+            const held = this.holdForExecPolicy(command, request);
+            if (held)
+                return held;
+            const useSsh = this.shellEndpoint.kind === 'ssh';
             const resolvedShell = this.resolveShell(request.shell);
-            if (resolvedShell.type === 'powershell') {
+            if (!useSsh && resolvedShell.type === 'powershell') {
                 // LLM 经常混写 cmd / bash 方言（&&、||、%VAR%）；Windows PowerShell 5.1
                 // 不支持这些语法，执行前做确定性转换，避免整条命令直接报解析错误。
                 const adapted = adaptCommandForPowerShell(command);
@@ -340,6 +411,17 @@ export class LocalExecutor {
             const timeout = Math.max(1000, rawTimeout);
             const cwd = this.resolveCwd(request.cwd, resolvedShell.type);
             const env = { ...process.env, ...(request.env || {}) };
+            if (this.shellBackend || useSsh || request.pty) {
+                return await this.runPlannedShell({
+                    command,
+                    request,
+                    resolvedShell,
+                    useSsh,
+                    guiCommand,
+                    timeout,
+                    cwd,
+                });
+            }
             const stdoutChunks = [];
             const stderrChunks = [];
             let stdoutBytes = 0;
@@ -444,6 +526,83 @@ export class LocalExecutor {
             return { success: false, error: message, platform: process.platform };
         }
     }
+    holdForExecPolicy(command, request) {
+        const evaluation = evaluateExecPolicy(command, this.execPolicy);
+        if (evaluation.decision === 'allow')
+            return null;
+        if (evaluation.decision === 'prompt' && request.execApproval === 'allow')
+            return null;
+        const shown = evaluation.command.join(' ');
+        const why = evaluation.rule?.justification ? ` (${evaluation.rule.justification})` : '';
+        if (evaluation.decision === 'forbidden') {
+            return {
+                success: false,
+                error: `exec policy forbids: ${shown}${why}`,
+                execDecision: 'forbidden',
+                platform: process.platform,
+            };
+        }
+        return {
+            success: false,
+            error: `exec policy requires approval: ${shown}${why}`,
+            execDecision: 'prompt',
+            needsFollowup: true,
+            platform: process.platform,
+        };
+    }
+    async runPlannedShell(input) {
+        const pty = input.request.pty === true;
+        const spec = input.useSsh
+            ? planSshArgv({
+                command: input.command,
+                cwd: input.request.cwd ? input.cwd : undefined,
+                pty,
+                shell: input.resolvedShell.type === 'powershell' ? 'powershell' : undefined,
+                endpoint: this.shellEndpoint,
+            })
+            : {
+                file: input.resolvedShell.shell,
+                args: [...input.resolvedShell.args, input.command],
+                cwd: input.cwd,
+                env: stringEnv(input.request.env),
+                pty,
+                transport: 'local',
+            };
+        if (input.useSsh) {
+            spec.cwd = os.homedir();
+            spec.env = stringEnv();
+        }
+        const backend = this.shellBackend ?? nodeShellBackend;
+        const outcome = await backend.run(spec, {
+            timeoutMs: input.timeout,
+            maxOutputBytes: this.maxOutputBytes,
+            gui: input.guiCommand,
+        });
+        const launched = outcome.stillRunning === true;
+        return {
+            success: launched || (!outcome.error && outcome.exitCode === 0),
+            stdout: launched
+                ? `${outcome.stdout}\n[GUI 程序已启动，仍在运行（等待 ${input.timeout}ms 后未退出，进程未被终止）。请在打开的界面中继续操作；不要重新执行同一条启动命令。]`
+                : outcome.stdout,
+            stderr: outcome.stderr,
+            exitCode: outcome.exitCode,
+            error: launched
+                ? undefined
+                : outcome.timedOut
+                    ? `Command timed out after ${input.timeout}ms (shell terminated; a launched GUI app may still be running). ` +
+                        'DO NOT blindly re-run the same launch command — if this launched a GUI/long-running program, ' +
+                        'first check whether it is already running, or re-run with a larger `timeout`, ' +
+                        'or start it detached (e.g. PowerShell Start-Process) so it does not block.'
+                    : outcome.error,
+            truncated: outcome.truncated,
+            timedOut: outcome.timedOut,
+            stillRunning: outcome.stillRunning,
+            shell: input.resolvedShell.type,
+            platform: process.platform,
+            transport: spec.transport,
+            pty: spec.pty,
+        };
+    }
     async readLocalFile(request, projectRoot, additionalReadRoots) {
         try {
             const filePath = this.resolvePath(request.path);
@@ -480,14 +639,11 @@ export class LocalExecutor {
             return { success: false, error: message };
         }
     }
-    async writeLocalFile(request, projectRoot) {
+    async writeLocalFile(request, projectRoot, additionalWriteRoots) {
         const filePath = this.resolvePath(request.path);
-        if (projectRoot) {
-            const root = this.resolvePath(projectRoot);
-            if (!isPathWithinRoot(filePath, root)) {
-                return { success: false, error: buildProjectRootViolation(filePath, root) };
-            }
-        }
+        const violation = writableFenceViolation(filePath, writableFenceRoots(projectRoot, additionalWriteRoots));
+        if (violation)
+            return { success: false, error: violation };
         // 同文件串行化：读-改-写必须排队，否则并发写会互相覆盖（pi file-mutation-queue）。
         return this.serializeFileOp(filePath, async () => {
             try {
@@ -544,14 +700,11 @@ export class LocalExecutor {
      * read-before-write 冲突检测，再在原文上做三级模糊定位 + 逆序替换，最后
      * 原子落盘。返回新版本令牌与统一 diff。
      */
-    async editLocalFile(request, projectRoot) {
+    async editLocalFile(request, projectRoot, additionalWriteRoots) {
         const filePath = this.resolvePath(request.path);
-        if (projectRoot) {
-            const root = this.resolvePath(projectRoot);
-            if (!isPathWithinRoot(filePath, root)) {
-                return { success: false, error: buildProjectRootViolation(filePath, root) };
-            }
-        }
+        const violation = writableFenceViolation(filePath, writableFenceRoots(projectRoot, additionalWriteRoots));
+        if (violation)
+            return { success: false, error: violation };
         return this.serializeFileOp(filePath, async () => {
             try {
                 const encoding = request.encoding ?? 'utf-8';
@@ -910,8 +1063,7 @@ export class LocalExecutor {
         });
     }
     resolvePath(inputPath) {
-        const expanded = inputPath.startsWith('~') ? path.join(os.homedir(), inputPath.slice(1)) : inputPath;
-        return path.resolve(expanded);
+        return expandFencePath(inputPath);
     }
     resolveCwd(cwd, shellType) {
         const resolved = this.resolvePath(cwd || os.homedir());

package/dist/mcp-executor.d.ts

@@ -1,13 +1,35 @@
+import { type StreamableHTTPReconnectionOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+export declare const MAX_MCP_SERVER_TOOLS = 64;
 /**
  * 给超时类错误追加可操作的排查提示。独立成纯函数便于单测。
  */
 export declare function withMcpTroubleshootHint(message: string): string;
-export interface McpServerConfig {
+export interface StdioMcpServerConfig {
+    transport: 'stdio';
     command: string;
     args?: string[];
     env?: Record<string, string>;
     cwd?: string;
 }
+export interface StreamableHttpMcpServerConfig {
+    transport: 'streamable-http';
+    url: string;
+    /** Non-sensitive literal headers. Authorization must come from an env reference. */
+    headers?: Record<string, string>;
+    /** Header name -> environment variable name. */
+    headersFromEnv?: Record<string, string>;
+    bearerTokenEnvVar?: string;
+    reconnect?: Partial<StreamableHTTPReconnectionOptions>;
+}
+export type McpServerConfig = StdioMcpServerConfig | StreamableHttpMcpServerConfig;
+export type LegacyMcpServerConfig = Omit<StdioMcpServerConfig, 'transport'>;
+export interface ListedTool {
+    name: string;
+    description: string;
+    inputSchema?: unknown;
+}
+export declare function resolveHttpHeaders(config: StreamableHttpMcpServerConfig, env?: Record<string, string | undefined>): Record<string, string>;
+export declare function mcpConfigKey(rawConfig: McpServerConfig | LegacyMcpServerConfig, env?: Record<string, string | undefined>): string;
 /**
  * Pure eviction predicate, split out so it's unit-testable without spinning
  * up a real MCP child process (`McpExecutor` isn't otherwise exported —
@@ -17,29 +39,39 @@ export declare function shouldEvictMcpConnection(entry: {
     lastUsed: number;
     inflight: number;
 }, now: number, idleTimeoutMs: number): boolean;
-declare class McpExecutor {
+export interface McpExecutorLike {
+    executeTool(config: McpServerConfig | LegacyMcpServerConfig, toolName: string, toolArgs: Record<string, unknown>): Promise<{
+        success: boolean;
+        text?: string;
+        error?: string;
+    }>;
+    listTools(config: McpServerConfig | LegacyMcpServerConfig, onChanged?: (tools: ListedTool[]) => void, onUnavailable?: (error: string) => void): Promise<{
+        success: boolean;
+        tools?: ListedTool[];
+        error?: string;
+    }>;
+}
+export declare class McpExecutor implements McpExecutorLike {
     private pool;
     private cleanupTimer;
     constructor();
-    executeTool(config: McpServerConfig, toolName: string, toolArgs: Record<string, unknown>): Promise<{
+    executeTool(rawConfig: McpServerConfig | LegacyMcpServerConfig, toolName: string, toolArgs: Record<string, unknown>): Promise<{
         success: boolean;
         text?: string;
         error?: string;
     }>;
-    listTools(config: McpServerConfig): Promise<{
+    listTools(rawConfig: McpServerConfig | LegacyMcpServerConfig, onChanged?: (tools: ListedTool[]) => void, onUnavailable?: (error: string) => void): Promise<{
         success: boolean;
-        tools?: {
-            name: string;
-            description: string;
-            inputSchema?: unknown;
-        }[];
+        tools?: ListedTool[];
         error?: string;
     }>;
     private getOrCreate;
+    private createTransport;
+    private refreshEntryTools;
+    private fetchEntryTools;
     private closeEntry;
     /** 关闭连接池中的所有连接（应用退出 / 测试收尾时调用）。 */
     shutdownAll(): Promise<void>;
     private evictIdle;
 }
 export declare const mcpExecutor: McpExecutor;
-export {};