@botbotgo/agent-harness 0.0.134 → 0.0.136

package/dist/config/agents/orchestra.yaml

@@ -1,7 +1,7 @@
 # agent-harness feature: schema version for this declarative config object.
 apiVersion: agent-harness/v1alpha1
 # agent-harness feature: object type discriminator.
-# Prefer the generic `Agent` form and select the concrete execution backend under `spec.execution`.
+# Prefer the generic `Agent` form and place execution fields directly under `spec`.
 kind: Agent
 metadata:
   # agent-harness feature: stable object id used for refs and runtime naming.
@@ -19,99 +19,98 @@ spec:
   # =====================
   # Runtime Agent Features
   # =====================
-  execution:
-    # Current backend adapter for this host profile.
-    backend: deepagent
-    # Upstream execution feature: model ref for the underlying LLM used by this execution host.
-    modelRef: model/default
-    memory:
-      # Upstream execution feature: bootstrap memory sources supplied to the selected backend at construction time.
-      # These paths resolve relative to the workspace root unless they are already absolute.
-      # Treat this as agent-owned startup context, not as a dynamic long-term memory sink:
-      # - keep `systemPrompt` for stable role, boundaries, and hard behavioral rules
-      # - use `memory:` for stable project knowledge, operating conventions, and shared or agent-specific context files
-      # - use `/memories/*` via the backend/store below for durable knowledge learned from prior runs
-      # - use the harness checkpointer for resumable graph state for an in-flight run
-      # Updating these files changes future agent constructions, but they are still bootstrap inputs rather than
-      # self-updating runtime memory.
-      - path: config/agent-context.md
-    # Upstream execution feature: top-level host starts with no extra direct tool refs beyond discovered workspace tools.
-    tools: []
-    # Upstream execution feature: top-level host starts with no explicit skill package refs in the default workspace.
-    skills: []
-    # Upstream execution feature: subagent topology is empty in the repository default and can be filled in YAML.
-    subagents: []
-    # Upstream execution feature: host-level MCP servers are opt-in and empty by default.
-    mcpServers: []
-    # Runtime execution feature: checkpointer config passed into the selected backend adapter.
-    # This persists resumable graph state for this agent.
-    # Available `kind` options in this harness: `FileCheckpointer`, `MemorySaver`, `SqliteSaver`.
-    # `path` is only used by `FileCheckpointer` and `SqliteSaver`; omit it for `MemorySaver`.
-    checkpointer:
-      ref: checkpointer/sqlite
-    # Upstream execution feature: store config passed into the selected backend adapter.
-    # In the default deepagent adapter this is the LangGraph store used by `StoreBackend` routes.
-    # Built-in kinds in this harness today: `FileStore`, `InMemoryStore`.
-    # Other store kinds should flow through a custom runtime resolver instead of being claimed as built in.
-    store:
-      ref: store/default
+  # Current backend adapter for this host profile.
+  backend: deepagent
+  # Upstream execution feature: model ref for the underlying LLM used by this execution host.
+  modelRef: model/default
+  memory:
+    # Upstream execution feature: bootstrap memory sources supplied to the selected backend at construction time.
+    # These paths resolve relative to the workspace root unless they are already absolute.
+    # Treat this as agent-owned startup context, not as a dynamic long-term memory sink:
+    # - keep `systemPrompt` for stable role, boundaries, and hard behavioral rules
+    # - use `memory:` for stable project knowledge, operating conventions, and shared or agent-specific context files
+    # - use `/memories/*` via the backend/store below for durable knowledge learned from prior runs
+    # - use the harness checkpointer for resumable graph state for an in-flight run
+    # Updating these files changes future agent constructions, but they are still bootstrap inputs rather than
+    # self-updating runtime memory.
+    - path: config/agent-context.md
+  # Upstream execution feature: top-level host starts with no extra direct tool refs beyond discovered workspace tools.
+  tools: []
+  # Upstream execution feature: top-level host starts with no explicit skill package refs in the default workspace.
+  skills: []
+  # Upstream execution feature: subagent topology is empty in the repository default and can be filled in YAML.
+  subagents: []
+  # Upstream execution feature: host-level MCP servers are opt-in and empty by default.
+  mcpServers: []
+  # Runtime execution feature: checkpointer config passed into the selected backend adapter.
+  # This persists resumable graph state for this agent.
+  # Available `kind` options in this harness: `FileCheckpointer`, `MemorySaver`, `SqliteSaver`.
+  # `path` is only used by `FileCheckpointer` and `SqliteSaver`; omit it for `MemorySaver`.
+  checkpointer:
+    ref: checkpointer/sqlite
+  # Upstream execution feature: store config passed into the selected backend adapter.
+  # In the default deepagent adapter this is the LangGraph store used by `StoreBackend` routes.
+  # Built-in kinds in this harness today: `FileStore`, `InMemoryStore`.
+  # Other store kinds should flow through a custom runtime resolver instead of being claimed as built in.
+  store:
+    ref: store/default
+  # Upstream execution feature: backend config passed into the selected backend adapter.
+  # Prefer a reusable backend preset via `ref` so backend topology stays declarative and reusable in YAML.
+  # The default preset keeps DeepAgent execution semantics upstream-owned:
+  # - workspace execution uses a lightweight VFS sandbox
+  # - long-term memory under `/memories/*` uses `StoreBackend`
+  # - `CompositeBackend` composes those backend instances together
+  # The harness injects the resolved store/checkpointer instances, but the backend topology itself stays upstream-shaped.
+  # Upstream execution feature: no extra declarative HITL rules by default.
+  interruptOn: {}
+  # Upstream execution feature: no extra declarative middleware beyond upstream deepagents defaults by default.
+  # Common upstream middleware kinds that this harness can compile directly from YAML:
+  # - `patchToolCalls`
+  # - `summarization`
+  # - `dynamicSystemPrompt`
+  # - `humanInTheLoop`
+  # - `todoList`
+  # - `pii`, `piiRedaction`
+  #
+  # DeepAgents already includes its own filesystem, planning, subagent, and memory semantics.
+  # Keep this list empty unless you are intentionally adding extra upstream middleware on top.
+  middleware: []
+  config:
     # Upstream execution feature: backend config passed into the selected backend adapter.
-    # Prefer a reusable backend preset via `ref` so backend topology stays declarative and reusable in YAML.
-    # The default preset keeps DeepAgent execution semantics upstream-owned:
-    # - workspace execution uses a lightweight VFS sandbox
-    # - long-term memory under `/memories/*` uses `StoreBackend`
-    # - `CompositeBackend` composes those backend instances together
-    # The harness injects the resolved store/checkpointer instances, but the backend topology itself stays upstream-shaped.
-    # Upstream execution feature: no extra declarative HITL rules by default.
-    interruptOn: {}
-    # Upstream execution feature: no extra declarative middleware beyond upstream deepagents defaults by default.
-    # Common upstream middleware kinds that this harness can compile directly from YAML:
-    # - `patchToolCalls`
-    # - `summarization`
-    # - `dynamicSystemPrompt`
-    # - `humanInTheLoop`
-    # - `todoList`
-    # - `pii`, `piiRedaction`
-    #
-    # DeepAgents already includes its own filesystem, planning, subagent, and memory semantics.
-    # Keep this list empty unless you are intentionally adding extra upstream middleware on top.
-    middleware: []
-    config:
-      # Upstream execution feature: backend config passed into the selected backend adapter.
-      # Keep this nested under `config` because `execution.backend` already selects the adapter mode.
-      backend:
-        ref: backend/default
-    # Upstream execution feature: system prompt for the orchestration host.
-    # This becomes the top-level instruction block for the selected execution backend and should hold the
-    # agent's durable role, priorities, and behavioral guardrails rather than bulky project facts.
-    systemPrompt: |-
-      You are the orchestra agent.
+    # Keep this nested under `config` because `backend` already selects the adapter mode.
+    backend:
+      ref: backend/default
+  # Upstream execution feature: system prompt for the orchestration host.
+  # This becomes the top-level instruction block for the selected execution backend and should hold the
+  # agent's durable role, priorities, and behavioral guardrails rather than bulky project facts.
+  systemPrompt: |-
+    You are the orchestra agent.
 
-      You are the default execution host.
-      Try to finish the request yourself before delegating.
-      Use your own tools first when they are sufficient.
-      Use your own skills first when they are sufficient.
-      Delegate only when a subagent is a clearly better fit or when your own tools and skills are not enough.
-      If neither you nor any suitable subagent can do the work, say so plainly.
+    You are the default execution host.
+    Try to finish the request yourself before delegating.
+    Use your own tools first when they are sufficient.
+    Use your own skills first when they are sufficient.
+    Delegate only when a subagent is a clearly better fit or when your own tools and skills are not enough.
+    If neither you nor any suitable subagent can do the work, say so plainly.
 
-      Do not delegate by reflex.
-      Do not delegate just because a task has multiple steps.
-      Do not delegate when a direct answer or a short local tool pass is enough.
-      Keep the critical path local when immediate progress depends on it; otherwise delegate bounded sidecar work to
-      the most appropriate subagent.
+    Do not delegate by reflex.
+    Do not delegate just because a task has multiple steps.
+    Do not delegate when a direct answer or a short local tool pass is enough.
+    Keep the critical path local when immediate progress depends on it; otherwise delegate bounded sidecar work to
+    the most appropriate subagent.
 
-      Use your own tools for lightweight discovery, inventory, and context gathering.
-      Prefer the structured checkout, indexing, retrieval, and inventory tools that are already attached to you over
-      ad hoc shell work when those tools are sufficient.
-      Use the attached subagent descriptions as the source of truth for what each subagent is for.
-      Do not delegate to a subagent whose description does not clearly match the task.
-      Integrate subagent results into one coherent answer and do not claim checks or evidence you did not obtain.
+    Use your own tools for lightweight discovery, inventory, and context gathering.
+    Prefer the structured checkout, indexing, retrieval, and inventory tools that are already attached to you over
+    ad hoc shell work when those tools are sufficient.
+    Use the attached subagent descriptions as the source of truth for what each subagent is for.
+    Do not delegate to a subagent whose description does not clearly match the task.
+    Integrate subagent results into one coherent answer and do not claim checks or evidence you did not obtain.
 
-      When the user asks about available tools, skills, or agents, use the attached inventory tools instead of
-      inferring from memory.
+    When the user asks about available tools, skills, or agents, use the attached inventory tools instead of
+    inferring from memory.
 
-      Write to `/memories/*` only when the information is durable, reusable across future runs or threads, and likely
-      to matter again: user preferences, project conventions, confirmed decisions, reusable summaries, and stable
-      ownership facts are good candidates.
-      Do not store transient reasoning, temporary plans, scratch work, one-off search results, or intermediate
-      outputs that can be cheaply recomputed.
+    Write to `/memories/*` only when the information is durable, reusable across future runs or threads, and likely
+    to matter again: user preferences, project conventions, confirmed decisions, reusable summaries, and stable
+    ownership facts are good candidates.
+    Do not store transient reasoning, temporary plans, scratch work, one-off search results, or intermediate
+    outputs that can be cheaply recomputed.

package/dist/contracts/workspace.d.ts

@@ -8,6 +8,8 @@ export type ParsedAgentObject = {
     modelRef: string;
     runRoot?: string;
     toolRefs: string[];
+    toolBindings?: ParsedAgentToolBinding[];
+    inlineTools?: ParsedToolObject[];
     mcpServers?: Array<Record<string, unknown>>;
     skillPathRefs: string[];
     memorySources: string[];
@@ -17,6 +19,10 @@ export type ParsedAgentObject = {
     deepAgentConfig?: Record<string, unknown>;
     sourcePath: string;
 };
+export type ParsedAgentToolBinding = {
+    ref: string;
+    overrides?: Record<string, unknown>;
+};
 export type WorkspaceObject = {
     id: string;
     kind: string;
@@ -72,7 +78,9 @@ export type ParsedToolObject = {
     description: string;
     implementationName?: string;
     config?: Record<string, unknown>;
+    subprocess?: boolean;
     inputSchemaRef?: string;
+    embeddingModelRef?: string;
     backendOperation?: string;
     mcpRef?: string;
     bundleRefs: string[];
@@ -116,7 +124,9 @@ export type CompiledTool = {
     name: string;
     description: string;
     config?: Record<string, unknown>;
+    subprocess?: boolean;
     inputSchemaRef?: string;
+    embeddingModelRef?: string;
     backendOperation?: string;
     mcpRef?: string;
     bundleRefs: string[];
@@ -239,7 +249,7 @@ export type CompiledAgentBinding = {
 };
 export type WorkspaceBundle = {
     workspaceRoot: string;
-    resourceSources: string[];
+    resources: string[];
     refs: Map<string, WorkspaceObject | ParsedAgentObject>;
     models: Map<string, ParsedModelObject>;
     embeddings: Map<string, ParsedEmbeddingModelObject>;
@@ -257,5 +267,5 @@ export type WorkspaceLoadOptions = {
      * Later values always override earlier values.
      */
     overlayRoots?: string[];
-    resourceSources?: string[];
+    resources?: string[];
 };

package/dist/extensions.js

@@ -15,7 +15,7 @@ function resolveToolRefId(ref) {
     if (ref.startsWith("builtin/")) {
         return ref;
     }
-    return ref.split("/").slice(1).join("/");
+    return ref.includes("/") ? ref.split("/").slice(1).join("/") : ref;
 }
 export function resolveToolTargets(tools, ref) {
     const resolved = resolveToolRefId(ref);
@@ -28,6 +28,10 @@ export function resolveToolTargets(tools, ref) {
     if (exact) {
         return [exact];
     }
+    const byName = Array.from(tools.values()).filter((tool) => tool.name === resolved);
+    if (byName.length > 0) {
+        return byName;
+    }
     if (!resolved.startsWith("builtin/")) {
         return [];
     }
@@ -118,7 +122,9 @@ registerToolKind({
                 name: tool.name,
                 description: tool.description,
                 config: tool.config,
+                subprocess: tool.subprocess,
                 inputSchemaRef: tool.inputSchemaRef,
+                embeddingModelRef: tool.embeddingModelRef,
                 bundleRefs: [],
                 hitl: tool.hitl
                     ? {
@@ -150,7 +156,9 @@ registerToolKind({
                 name: tool.name,
                 description: tool.description,
                 config: tool.config,
+                subprocess: tool.subprocess,
                 inputSchemaRef: tool.inputSchemaRef,
+                embeddingModelRef: tool.embeddingModelRef,
                 backendOperation: tool.backendOperation,
                 bundleRefs: [],
                 hitl: tool.hitl
@@ -183,7 +191,9 @@ registerToolKind({
                 name: tool.name,
                 description: tool.description,
                 config: tool.config,
+                subprocess: tool.subprocess,
                 inputSchemaRef: tool.inputSchemaRef,
+                embeddingModelRef: tool.embeddingModelRef,
                 mcpRef: tool.mcpRef,
                 bundleRefs: [],
                 hitl: tool.hitl
@@ -222,7 +232,9 @@ registerToolKind({
                 name: tool.name,
                 description: tool.description,
                 config: tool.config,
+                subprocess: tool.subprocess,
                 inputSchemaRef: tool.inputSchemaRef,
+                embeddingModelRef: tool.embeddingModelRef,
                 bundleRefs: [],
                 hitl: tool.hitl
                     ? {

package/dist/init-project.js

@@ -190,8 +190,8 @@ spec:
 `;
 }
 function renderResearchAgentYaml(options) {
-    const toolsBlock = options.withWebSearch ? "    tools:\n      - ref: tool/web-search\n" : "    tools: []\n";
-    const subagentsBlock = options.template === "deep-research" ? "    subagents:\n      - ref: agent/research-analyst\n" : "    subagents: []\n";
+    const toolsBlock = options.withWebSearch ? "  tools:\n    - web-search\n" : "  tools: []\n";
+    const subagentsBlock = options.template === "deep-research" ? "  subagents:\n    - ref: agent/research-analyst\n" : "  subagents: []\n";
     const prompt = options.withWebSearch
         ? "Break complex research requests into a clear plan, use web search when current information matters, and return a concise synthesis with sources and explicit uncertainty."
         : "Break complex research requests into a clear plan and return a concise synthesis with explicit assumptions and uncertainty.";
@@ -207,19 +207,18 @@ spec:
   runtime:
     runtimeMemory:
       ref: runtime-memory/default
-  execution:
-    backend: deepagent
-    modelRef: model/default
-${toolsBlock}    skills:
-      - path: ./
-${subagentsBlock}    config:
-      backend:
-        ref: backend/default
-    systemPrompt: ${prompt}${delegationLine}
+  backend: deepagent
+  modelRef: model/default
+${toolsBlock}  skills:
+    - deep-research
+${subagentsBlock}  config:
+    backend:
+      ref: backend/default
+  systemPrompt: ${prompt}${delegationLine}
 `;
 }
 function renderResearchAnalystYaml(options) {
-    const toolsBlock = options.withWebSearch ? "    tools:\n      - ref: tool/web-search\n" : "    tools: []\n";
+    const toolsBlock = options.withWebSearch ? "  tools:\n    - web-search\n" : "  tools: []\n";
     const prompt = options.withWebSearch
         ? "Gather current sources, compare claims carefully, extract the most decision-relevant facts, and return clean notes the host agent can synthesize."
         : "Break down the problem, compare alternatives carefully, extract the most decision-relevant facts, and return clean notes the host agent can synthesize.";
@@ -232,15 +231,14 @@ spec:
   runtime:
     runtimeMemory:
       ref: runtime-memory/default
-  execution:
-    backend: deepagent
-    modelRef: model/default
-${toolsBlock}    skills:
-      - path: ./
-    config:
-      backend:
-        ref: backend/default
-    systemPrompt: ${prompt}
+  backend: deepagent
+  modelRef: model/default
+${toolsBlock}  skills:
+    - deep-research
+  config:
+    backend:
+      ref: backend/default
+  systemPrompt: ${prompt}
 `;
 }
 function renderResourcePackageJson(projectSlug) {

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.133";
+export declare const AGENT_HARNESS_VERSION = "0.0.135";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.133";
+export const AGENT_HARNESS_VERSION = "0.0.135";

package/dist/resource/mcp-tool-support.d.ts

@@ -17,5 +17,9 @@ export type McpToolDescriptor = {
 };
 export declare function readMcpServerConfig(workspace: WorkspaceBundle, tool: WorkspaceBundle["tools"] extends Map<any, infer T> ? T : never): McpServerConfig | null;
 export declare function getOrCreateMcpClient(config: McpServerConfig): Promise<Client>;
+export declare function closeMcpClientsForWorkspace(workspace: WorkspaceBundle): Promise<void>;
+export declare function __resetMcpClientCacheForTests(): void;
+export declare function __setMcpClientCacheEntryForTests(config: McpServerConfig, clientPromise: Promise<Client>): void;
+export declare function __setMcpClientLoaderForTests(loader: (config: McpServerConfig) => Promise<Client>): void;
 export declare function listRemoteMcpTools(config: McpServerConfig): Promise<McpToolDescriptor[]>;
 export declare function createMcpToolResolver(workspace: WorkspaceBundle): NonNullable<RuntimeAdapterOptions["toolResolver"]>;

package/dist/resource/mcp-tool-support.js

@@ -6,6 +6,7 @@ import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/webso
 import { AGENT_HARNESS_VERSION } from "../package-version.js";
 import { createRuntimeEnv } from "../runtime/support/runtime-env.js";
 const mcpClientCache = new Map();
+let mcpClientLoader = createConnectedMcpClient;
 function readStringRecord(value) {
     if (typeof value !== "object" || !value) {
         return undefined;
@@ -73,46 +74,124 @@ function createMcpCacheKey(config) {
         headers: config.headers ?? {},
     });
 }
+async function createConnectedMcpClient(config) {
+    const client = new Client({
+        name: "agent-harness",
+        version: AGENT_HARNESS_VERSION,
+    });
+    const headers = {
+        ...(config.headers ?? {}),
+        ...(config.token ? { Authorization: `Bearer ${config.token}` } : {}),
+    };
+    const transport = config.transport === "http"
+        ? new StreamableHTTPClientTransport(new URL(config.url ?? ""), {
+            requestInit: Object.keys(headers).length > 0 ? { headers } : undefined,
+        })
+        : config.transport === "sse"
+            ? new SSEClientTransport(new URL(config.url ?? ""), {
+                requestInit: Object.keys(headers).length > 0 ? { headers } : undefined,
+            })
+            : config.transport === "websocket"
+                ? new WebSocketClientTransport(new URL(config.url ?? ""))
+                : new StdioClientTransport({
+                    command: config.command ?? "",
+                    args: config.args,
+                    env: createRuntimeEnv(config.env),
+                    cwd: config.cwd,
+                });
+    await client.connect(transport);
+    return client;
+}
+function isRecoverableMcpError(error) {
+    if (typeof error !== "object" || error === null) {
+        return false;
+    }
+    const message = typeof error.message === "string"
+        ? (error.message).toLowerCase()
+        : "";
+    const code = typeof error.code === "string"
+        ? (error.code).toLowerCase()
+        : "";
+    return [
+        "connection closed",
+        "transport closed",
+        "socket closed",
+        "stream closed",
+        "network socket disconnected",
+    ].some((pattern) => message.includes(pattern))
+        || ["econnreset", "epipe", "ehostunreach", "ecancelled"].includes(code);
+}
+async function closeCachedMcpClient(cacheKey) {
+    const cached = mcpClientCache.get(cacheKey);
+    mcpClientCache.delete(cacheKey);
+    if (!cached) {
+        return;
+    }
+    try {
+        const client = await cached;
+        await client.close();
+    }
+    catch {
+        // Ignore teardown failures for clients that never connected successfully.
+    }
+}
+async function invalidateMcpClient(config) {
+    await closeCachedMcpClient(createMcpCacheKey(config));
+}
+async function withRecoveredMcpClient(config, operation) {
+    const client = await getOrCreateMcpClient(config);
+    try {
+        return await operation(client);
+    }
+    catch (error) {
+        if (!isRecoverableMcpError(error)) {
+            throw error;
+        }
+        await invalidateMcpClient(config);
+        return operation(await getOrCreateMcpClient(config));
+    }
+}
 export async function getOrCreateMcpClient(config) {
     const cacheKey = createMcpCacheKey(config);
     const cached = mcpClientCache.get(cacheKey);
     if (cached) {
         return cached;
     }
-    const loading = (async () => {
-        const client = new Client({
-            name: "agent-harness",
-            version: AGENT_HARNESS_VERSION,
-        });
-        const headers = {
-            ...(config.headers ?? {}),
-            ...(config.token ? { Authorization: `Bearer ${config.token}` } : {}),
-        };
-        const transport = config.transport === "http"
-            ? new StreamableHTTPClientTransport(new URL(config.url ?? ""), {
-                requestInit: Object.keys(headers).length > 0 ? { headers } : undefined,
-            })
-            : config.transport === "sse"
-                ? new SSEClientTransport(new URL(config.url ?? ""), {
-                    requestInit: Object.keys(headers).length > 0 ? { headers } : undefined,
-                })
-                : config.transport === "websocket"
-                    ? new WebSocketClientTransport(new URL(config.url ?? ""))
-                    : new StdioClientTransport({
-                        command: config.command ?? "",
-                        args: config.args,
-                        env: createRuntimeEnv(config.env),
-                        cwd: config.cwd,
-                    });
-        await client.connect(transport);
-        return client;
-    })();
+    const loading = mcpClientLoader(config).catch((error) => {
+        if (mcpClientCache.get(cacheKey) === loading) {
+            mcpClientCache.delete(cacheKey);
+        }
+        throw error;
+    });
     mcpClientCache.set(cacheKey, loading);
     return loading;
 }
+export async function closeMcpClientsForWorkspace(workspace) {
+    const cacheKeys = new Set();
+    for (const tool of workspace.tools.values()) {
+        if (tool.type !== "mcp") {
+            continue;
+        }
+        const config = readMcpServerConfig(workspace, tool);
+        if (!config) {
+            continue;
+        }
+        cacheKeys.add(createMcpCacheKey(config));
+    }
+    await Promise.all(Array.from(cacheKeys, (cacheKey) => closeCachedMcpClient(cacheKey)));
+}
+export function __resetMcpClientCacheForTests() {
+    mcpClientCache.clear();
+    mcpClientLoader = createConnectedMcpClient;
+}
+export function __setMcpClientCacheEntryForTests(config, clientPromise) {
+    mcpClientCache.set(createMcpCacheKey(config), clientPromise);
+}
+export function __setMcpClientLoaderForTests(loader) {
+    mcpClientLoader = loader;
+}
 async function getRemoteMcpToolDescriptor(config, remoteToolName) {
-    const client = await getOrCreateMcpClient(config);
-    const result = await client.listTools();
+    const result = await withRecoveredMcpClient(config, (client) => client.listTools());
     const tool = result.tools.find((item) => typeof item.name === "string" && item.name === remoteToolName);
     if (!tool || typeof tool.name !== "string") {
         return null;
@@ -124,8 +203,7 @@ async function getRemoteMcpToolDescriptor(config, remoteToolName) {
     };
 }
 export async function listRemoteMcpTools(config) {
-    const client = await getOrCreateMcpClient(config);
-    const result = await client.listTools();
+    const result = await withRecoveredMcpClient(config, (client) => client.listTools());
     return result.tools
         .filter((tool) => typeof tool.name === "string")
         .map((tool) => ({
@@ -155,11 +233,10 @@ export function createMcpToolResolver(workspace) {
                 description: tool.description,
                 inputSchemaPromise: descriptorPromise.then((descriptor) => descriptor?.inputSchema),
                 async invoke(input) {
-                    const client = await getOrCreateMcpClient(serverConfig);
-                    const result = await client.callTool({
+                    const result = await withRecoveredMcpClient(serverConfig, (client) => client.callTool({
                         name: remoteToolName,
                         arguments: typeof input === "object" && input !== null ? input : {},
-                    });
+                    }));
                     const textParts = Array.isArray(result.content)
                         ? result.content
                             .filter((item) => typeof item === "object" && item !== null && "type" in item)