@bastani/atomic 0.9.16-alpha.1 → 0.9.16-alpha.3

package/dist/builtin/mcp/oauth-handler.ts

@@ -1,60 +0,0 @@
-// oauth-handler.ts - OAuth token management for MCP servers
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { getAgentPath } from "./agent-dir.ts";
-import type { OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
-
-// Token storage path for a server
-function getTokensPath(serverName: string): string {
-  const override = process.env.MCP_OAUTH_DIR?.trim();
-  const authDir = override ? override : getAgentPath("mcp-oauth");
-  return join(authDir, serverName, "tokens.json");
-}
-
-/**
- * Get stored OAuth tokens for a server (if any).
- * Returns undefined if no tokens or tokens are expired.
- * 
- * Token file location: $MCP_OAUTH_DIR/<server>/tokens.json when set,
- * otherwise <Pi agent dir>/mcp-oauth/<server>/tokens.json
- * 
- * Expected format:
- * {
- *   "access_token": "...",
- *   "token_type": "bearer",
- *   "refresh_token": "...",  // optional
- *   "expires_in": 3600,      // optional, seconds
- *   "expiresAt": 1234567890  // optional, absolute timestamp ms
- * }
- */
-export function getStoredTokens(serverName: string): OAuthTokens | undefined {
-  const tokensPath = getTokensPath(serverName);
-  
-  if (!existsSync(tokensPath)) return undefined;
-  
-  try {
-    const stored = JSON.parse(readFileSync(tokensPath, "utf-8"));
-    
-    // Validate required field
-    if (!stored.access_token || typeof stored.access_token !== "string") {
-      return undefined;
-    }
-    
-    // Check expiration if expiresAt is set
-    if (stored.expiresAt && typeof stored.expiresAt === "number") {
-      if (Date.now() > stored.expiresAt) {
-        // Token expired
-        return undefined;
-      }
-    }
-    
-    return {
-      access_token: stored.access_token,
-      token_type: stored.token_type ?? "bearer",
-      refresh_token: stored.refresh_token,
-      expires_in: stored.expires_in,
-    };
-  } catch {
-    return undefined;
-  }
-}

package/dist/builtin/mcp/onboarding-state.ts

@@ -1,68 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "node:fs";
-import { dirname } from "node:path";
-import { getAgentPath } from "./agent-dir.ts";
-
-export interface McpOnboardingState {
-  version: 1;
-  sharedConfigHintShown: boolean;
-  setupCompleted: boolean;
-  lastDiscoveryFingerprint?: string;
-}
-
-const DEFAULT_STATE: McpOnboardingState = {
-  version: 1,
-  sharedConfigHintShown: false,
-  setupCompleted: false,
-};
-
-export function getOnboardingStatePath(): string {
-  return getAgentPath("mcp-onboarding.json");
-}
-
-export function loadOnboardingState(): McpOnboardingState {
-  const path = getOnboardingStatePath();
-  if (!existsSync(path)) return { ...DEFAULT_STATE };
-
-  try {
-    const raw = JSON.parse(readFileSync(path, "utf-8")) as Partial<McpOnboardingState>;
-    if (!raw || typeof raw !== "object") return { ...DEFAULT_STATE };
-    return {
-      version: 1,
-      sharedConfigHintShown: raw.sharedConfigHintShown === true,
-      setupCompleted: raw.setupCompleted === true,
-      lastDiscoveryFingerprint: typeof raw.lastDiscoveryFingerprint === "string" ? raw.lastDiscoveryFingerprint : undefined,
-    };
-  } catch {
-    return { ...DEFAULT_STATE };
-  }
-}
-
-export function saveOnboardingState(state: McpOnboardingState): void {
-  const path = getOnboardingStatePath();
-  mkdirSync(dirname(path), { recursive: true });
-  const tmpPath = `${path}.${process.pid}.tmp`;
-  writeFileSync(tmpPath, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
-  renameSync(tmpPath, path);
-}
-
-export function updateOnboardingState(updater: (state: McpOnboardingState) => McpOnboardingState): McpOnboardingState {
-  const next = updater(loadOnboardingState());
-  saveOnboardingState(next);
-  return next;
-}
-
-export function markSharedConfigHintShown(fingerprint?: string): McpOnboardingState {
-  return updateOnboardingState((state) => ({
-    ...state,
-    sharedConfigHintShown: true,
-    lastDiscoveryFingerprint: fingerprint ?? state.lastDiscoveryFingerprint,
-  }));
-}
-
-export function markSetupCompleted(fingerprint?: string): McpOnboardingState {
-  return updateOnboardingState((state) => ({
-    ...state,
-    setupCompleted: true,
-    lastDiscoveryFingerprint: fingerprint ?? state.lastDiscoveryFingerprint,
-  }));
-}

package/dist/builtin/mcp/proxy-auth.ts

@@ -1,61 +0,0 @@
-import type { McpExtensionState } from "./state.js";
-import { authenticate, supportsOAuth } from "./mcp-auth-flow.js";
-import { formatAuthRequiredMessage } from "./utils.js";
-
-export type AutoAuthResult =
-  | { status: "skipped" }
-  | { status: "success" }
-  | { status: "failed"; message: string };
-
-export function getAuthRequiredMessage(
-  state: McpExtensionState,
-  serverName: string,
-  defaultMessage = `Server "${serverName}" requires OAuth authentication. Run /mcp-auth ${serverName} first.`,
-): string {
-  return formatAuthRequiredMessage(state.config, serverName, defaultMessage);
-}
-
-function getAuthFailedMessage(state: McpExtensionState, serverName: string, message: string): string {
-  const customGuidance = state.config.settings?.authRequiredMessage;
-  if (customGuidance) {
-    return `OAuth authentication failed for "${serverName}": ${message}. ${getAuthRequiredMessage(state, serverName)}`;
-  }
-  return `OAuth authentication failed for "${serverName}": ${message}. Run /mcp-auth ${serverName} first.`;
-}
-
-export async function attemptAutoAuth(
-  state: McpExtensionState,
-  serverName: string,
-): Promise<AutoAuthResult> {
-  if (state.config.settings?.autoAuth !== true) {
-    return { status: "skipped" };
-  }
-
-  const definition = state.config.mcpServers[serverName];
-  if (!definition || !supportsOAuth(definition) || !definition.url) {
-    return { status: "skipped" };
-  }
-
-  const grantType = definition.oauth ? definition.oauth.grantType ?? "authorization_code" : "authorization_code";
-  if (!state.ui && grantType !== "client_credentials") {
-    return {
-      status: "failed",
-      message: getAuthRequiredMessage(
-        state,
-        serverName,
-        `Server "${serverName}" requires OAuth authentication. Run /mcp-auth ${serverName} in an interactive session.`,
-      ),
-    };
-  }
-
-  try {
-    await authenticate(serverName, definition.url, definition);
-    return { status: "success" };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      status: "failed",
-      message: getAuthFailedMessage(state, serverName, message),
-    };
-  }
-}

package/dist/builtin/mcp/proxy-call.ts

@@ -1,447 +0,0 @@
-import type { ToolInfo } from "@bastani/atomic";
-import type { McpExtensionState } from "./state.js";
-import type { McpContent, ToolMetadata } from "./types.ts";
-import { getServerPrefix } from "./types.ts";
-import { lazyConnect, updateServerMetadata, updateMetadataCache, getFailureAgeSeconds, updateStatusBar } from "./init.js";
-import { getToolNames, findToolByName, formatSchema } from "./tool-metadata.js";
-import { transformMcpContent } from "./tool-registrar.js";
-import { maybeStartUiSession, type UiSessionRuntime } from "./ui-session.js";
-import { unflattenToolArguments } from "./utils.js";
-import { attemptAutoAuth, getAuthRequiredMessage, type AutoAuthResult } from "./proxy-auth.js";
-import type { ProxyToolResult } from "./proxy-types.js";
-import { waitForCaller, waitForCallerWithLateCleanup } from "./caller-wait.js";
-import { notifyUiCancellation, rethrowHostAbortAfterUiCancellation } from "./apps-cancellation.js";
-import { asCallToolResult } from "./call-tool-result.js";
-import { assertMcpStateLease, McpStateChangedError, type AssertMcpStateLease } from "./state-lease.js";
-import { callToolWithConfiguredTimeout, formatMcpToolCallFailure } from "./tool-call-timeout.js";
-
-export async function executeCall(
-  state: McpExtensionState,
-  toolName: string,
-  args?: Record<string, unknown>,
-  serverOverride?: string,
-  getPiTools?: () => ToolInfo[],
-  signal?: AbortSignal,
-  startAutoAuth: (state: McpExtensionState, serverName: string) => Promise<AutoAuthResult> = attemptAutoAuth,
-  assertActive?: AssertMcpStateLease,
-): Promise<ProxyToolResult> {
-  signal?.throwIfAborted();
-  assertMcpStateLease(assertActive);
-  let serverName: string | undefined = serverOverride;
-  let toolMeta: ToolMetadata | undefined;
-  let autoAuthAttempted = false;
-  const prefixMode = state.config.settings?.toolPrefix ?? "server";
-
-  if (serverName && !state.config.mcpServers[serverName]) {
-    return {
-      content: [{ type: "text" as const, text: `Server "${serverName}" not found. Use mcp({}) to see available servers.` }],
-      details: { mode: "call", error: "server_not_found", server: serverName },
-    };
-  }
-
-  if (serverName) {
-    toolMeta = findToolByName(state.toolMetadata.get(serverName), toolName);
-  } else {
-    for (const [server, metadata] of state.toolMetadata.entries()) {
-      const found = findToolByName(metadata, toolName);
-      if (found) {
-        serverName = server;
-        toolMeta = found;
-        break;
-      }
-    }
-  }
-
-  if (serverName && !toolMeta) {
-    const connected = await waitForCaller(() => lazyConnect(state, serverName!), signal);
-    signal?.throwIfAborted();
-    assertMcpStateLease(assertActive);
-    if (connected) {
-      toolMeta = findToolByName(state.toolMetadata.get(serverName), toolName);
-    } else {
-      const needsAuthConnection = state.manager.getConnection(serverName);
-      if (needsAuthConnection?.status === "needs-auth") {
-        autoAuthAttempted = true;
-        const autoAuth = await waitForCaller(() => startAutoAuth(state, serverName!), signal);
-        signal?.throwIfAborted();
-        assertMcpStateLease(assertActive);
-        if (autoAuth.status === "failed") {
-          return {
-            content: [{ type: "text" as const, text: autoAuth.message }],
-            details: { mode: "call", error: "auth_required", server: serverName, message: autoAuth.message },
-          };
-        }
-        if (autoAuth.status === "success") {
-          await waitForCaller(() => state.manager.close(serverName!), signal);
-          signal?.throwIfAborted();
-          assertMcpStateLease(assertActive);
-          state.failureTracker.delete(serverName);
-          const connectedAfterAuth = await waitForCaller(() => lazyConnect(state, serverName!), signal);
-          signal?.throwIfAborted();
-          assertMcpStateLease(assertActive);
-          if (connectedAfterAuth) {
-            toolMeta = findToolByName(state.toolMetadata.get(serverName), toolName);
-            if (!toolMeta) {
-              return {
-                content: [{ type: "text" as const, text: `Tool "${toolName}" not found on "${serverName}" after reconnect.` }],
-                details: { mode: "call", error: "tool_not_found_after_reconnect", requestedTool: toolName },
-              };
-            }
-          }
-        }
-
-        if (!toolMeta && state.manager.getConnection(serverName)?.status === "needs-auth") {
-          const message = getAuthRequiredMessage(state, serverName);
-          return {
-            content: [{ type: "text" as const, text: message }],
-            details: { mode: "call", error: "auth_required", server: serverName, message },
-          };
-        }
-      }
-
-      if (!toolMeta) {
-        const failedAgo = getFailureAgeSeconds(state, serverName);
-        if (failedAgo !== null) {
-          return {
-            content: [{ type: "text" as const, text: `Server "${serverName}" not available (last failed ${failedAgo}s ago)` }],
-            details: { mode: "call", error: "server_backoff", server: serverName },
-          };
-        }
-      }
-    }
-  }
-
-  let prefixMatchedServer: string | undefined;
-
-  if (!serverName && !toolMeta && prefixMode !== "none") {
-    const candidates = Object.keys(state.config.mcpServers)
-      .map(name => ({ name, prefix: getServerPrefix(name, prefixMode) }))
-      .filter(c => c.prefix && toolName.startsWith(c.prefix + "_"))
-      .sort((a, b) => b.prefix.length - a.prefix.length);
-
-    for (const { name: configuredServer } of candidates) {
-      const existingConnection = state.manager.getConnection(configuredServer);
-      const failedAgo = getFailureAgeSeconds(state, configuredServer);
-      if (failedAgo !== null && existingConnection?.status !== "needs-auth") continue;
-
-      let connected = await waitForCaller(() => lazyConnect(state, configuredServer), signal);
-      signal?.throwIfAborted();
-      assertMcpStateLease(assertActive);
-      if (!connected && state.manager.getConnection(configuredServer)?.status === "needs-auth" && !autoAuthAttempted) {
-        autoAuthAttempted = true;
-        const autoAuth = await waitForCaller(() => startAutoAuth(state, configuredServer), signal);
-        signal?.throwIfAborted();
-        assertMcpStateLease(assertActive);
-        if (autoAuth.status === "failed") {
-          return {
-            content: [{ type: "text" as const, text: autoAuth.message }],
-            details: { mode: "call", error: "auth_required", server: configuredServer, message: autoAuth.message },
-          };
-        }
-        if (autoAuth.status === "success") {
-          await waitForCaller(() => state.manager.close(configuredServer), signal);
-          signal?.throwIfAborted();
-          assertMcpStateLease(assertActive);
-          state.failureTracker.delete(configuredServer);
-          connected = await waitForCaller(() => lazyConnect(state, configuredServer), signal);
-          signal?.throwIfAborted();
-          assertMcpStateLease(assertActive);
-        }
-      }
-
-      if (!connected) continue;
-      if (!prefixMatchedServer) prefixMatchedServer = configuredServer;
-      toolMeta = findToolByName(state.toolMetadata.get(configuredServer), toolName);
-      if (toolMeta) {
-        serverName = configuredServer;
-        break;
-      }
-    }
-  }
-
-  if (!serverName || !toolMeta) {
-    const nativeTool = !serverOverride
-      ? getPiTools?.().find((tool) => tool.name === toolName && tool.name !== "mcp")
-      : undefined;
-    if (nativeTool) {
-      return {
-        content: [{ type: "text" as const, text: `"${toolName}" is a native Pi tool. Call ${toolName} directly instead of using mcp({ tool: "${toolName}" }).` }],
-        details: { mode: "call", error: "native_tool", requestedTool: toolName },
-      };
-    }
-
-    const hintServer = serverName ?? prefixMatchedServer;
-    const available = hintServer ? getToolNames(state, hintServer) : [];
-    let msg = `Tool "${toolName}" not found.`;
-    if (available.length > 0) {
-      msg += ` Server "${hintServer}" has: ${available.join(", ")}`;
-    } else {
-      msg += ` Use mcp({ search: "..." }) to search.`;
-    }
-    return {
-      content: [{ type: "text" as const, text: msg }],
-      details: { mode: "call", error: "tool_not_found", requestedTool: toolName, hintServer },
-    };
-  }
-
-  let connection = state.manager.getConnection(serverName);
-  if (connection?.status === "needs-auth") {
-    if (!autoAuthAttempted) {
-      autoAuthAttempted = true;
-      const autoAuth = await waitForCaller(() => startAutoAuth(state, serverName!), signal);
-      signal?.throwIfAborted();
-      assertMcpStateLease(assertActive);
-      if (autoAuth.status === "failed") {
-        return {
-          content: [{ type: "text" as const, text: autoAuth.message }],
-          details: { mode: "call", error: "auth_required", server: serverName, message: autoAuth.message },
-        };
-      }
-      if (autoAuth.status === "success") {
-        await waitForCaller(() => state.manager.close(serverName!), signal);
-        signal?.throwIfAborted();
-        assertMcpStateLease(assertActive);
-        state.failureTracker.delete(serverName);
-        connection = state.manager.getConnection(serverName);
-      }
-    }
-
-    if (connection?.status === "needs-auth") {
-      const message = getAuthRequiredMessage(state, serverName);
-      return {
-        content: [{ type: "text" as const, text: message }],
-        details: { mode: "call", error: "auth_required", server: serverName, message },
-      };
-    }
-  }
-  if (!connection || connection.status !== "connected") {
-    const failedAgo = getFailureAgeSeconds(state, serverName);
-    if (failedAgo !== null) {
-      return {
-        content: [{ type: "text" as const, text: `Server "${serverName}" not available (last failed ${failedAgo}s ago)` }],
-        details: { mode: "call", error: "server_backoff", server: serverName },
-      };
-    }
-
-    const definition = state.config.mcpServers[serverName];
-    if (!definition) {
-      return {
-        content: [{ type: "text" as const, text: `Server "${serverName}" not connected` }],
-        details: { mode: "call", error: "server_not_connected", server: serverName },
-      };
-    }
-
-    try {
-      assertMcpStateLease(assertActive);
-      if (state.ui) {
-        state.ui.setStatus("mcp", `MCP: connecting to ${serverName}...`);
-      }
-      connection = await waitForCaller(() => state.manager.connect(serverName, definition), signal);
-      signal?.throwIfAborted();
-      assertMcpStateLease(assertActive);
-      if (connection.status === "needs-auth") {
-        if (!autoAuthAttempted) {
-          autoAuthAttempted = true;
-          const autoAuth = await waitForCaller(() => startAutoAuth(state, serverName!), signal);
-          signal?.throwIfAborted();
-          assertMcpStateLease(assertActive);
-          if (autoAuth.status === "failed") {
-            return {
-              content: [{ type: "text" as const, text: autoAuth.message }],
-              details: { mode: "call", error: "auth_required", server: serverName, message: autoAuth.message },
-            };
-          }
-          if (autoAuth.status === "success") {
-            await waitForCaller(() => state.manager.close(serverName!), signal);
-            signal?.throwIfAborted();
-            assertMcpStateLease(assertActive);
-            connection = await waitForCaller(() => state.manager.connect(serverName, definition), signal);
-            signal?.throwIfAborted();
-            assertMcpStateLease(assertActive);
-          }
-        }
-
-        if (connection.status === "needs-auth") {
-          const message = getAuthRequiredMessage(state, serverName);
-          return {
-            content: [{ type: "text" as const, text: message }],
-            details: { mode: "call", error: "auth_required", server: serverName, message },
-          };
-        }
-      }
-      assertMcpStateLease(assertActive);
-      state.failureTracker.delete(serverName);
-      updateServerMetadata(state, serverName);
-      updateMetadataCache(state, serverName);
-      updateStatusBar(state);
-      toolMeta = findToolByName(state.toolMetadata.get(serverName), toolName);
-      if (!toolMeta) {
-        const available = getToolNames(state, serverName);
-        const hint = available.length > 0
-          ? `Available tools on "${serverName}": ${available.join(", ")}`
-          : `Server "${serverName}" has no tools.`;
-        return {
-          content: [{ type: "text" as const, text: `Tool "${toolName}" not found on "${serverName}" after reconnect. ${hint}` }],
-          details: { mode: "call", error: "tool_not_found_after_reconnect", requestedTool: toolName },
-        };
-      }
-    } catch (error) {
-      signal?.throwIfAborted();
-      assertMcpStateLease(assertActive);
-      state.failureTracker.set(serverName, Date.now());
-      updateStatusBar(state);
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        content: [{ type: "text" as const, text: `Failed to connect to "${serverName}": ${message}` }],
-        details: { mode: "call", error: "connect_failed", message },
-      };
-    }
-  }
-  const definition = state.config.mcpServers[serverName] ?? connection.definition;
-
-  let uiSession: UiSessionRuntime | null = null;
-
-  try {
-    assertMcpStateLease(assertActive);
-    state.manager.touch(serverName);
-    state.manager.incrementInFlight(serverName);
-
-    if (toolMeta.resourceUri) {
-      assertMcpStateLease(assertActive);
-      const result = await connection.client.readResource({ uri: toolMeta.resourceUri }, { signal });
-      signal?.throwIfAborted();
-      assertMcpStateLease(assertActive);
-      const content = (result.contents ?? []).map(c => ({
-        type: "text" as const,
-        text: "text" in c ? c.text : ("blob" in c ? `[Binary data: ${(c as { mimeType?: string }).mimeType ?? "unknown"}]` : JSON.stringify(c)),
-      }));
-      return {
-        content: content.length > 0 ? content : [{ type: "text" as const, text: "(empty resource)" }],
-        details: { mode: "call", resourceUri: toolMeta.resourceUri, server: serverName },
-      };
-    }
-
-    uiSession = toolMeta.uiResourceUri
-      ? await waitForCallerWithLateCleanup(
-          () => maybeStartUiSession(state, {
-            serverName,
-            toolName: toolMeta.originalName,
-            toolArgs: args ?? {},
-            uiResourceUri: toolMeta.uiResourceUri!,
-            streamMode: toolMeta.uiStreamMode,
-          }),
-          signal,
-          (lateSession) => {
-            if (lateSession && !lateSession.reused) lateSession.close("caller cancelled during UI startup");
-          },
-        )
-      : null;
-    signal?.throwIfAborted();
-    assertMcpStateLease(assertActive);
-
-    assertMcpStateLease(assertActive);
-    const resultPromise = callToolWithConfiguredTimeout(connection.client, {
-      name: toolMeta.originalName,
-      // Normalize provider-flattened argument keys (e.g. Gemini's `keywords[0]`)
-      // back into arrays/objects before the MCP server validates them.
-      // Schema-aware: literal dotted property names (e.g. `filter.name`) are
-      // preserved unless the schema proves the head is a container.
-      arguments: unflattenToolArguments(args, toolMeta.inputSchema),
-      _meta: uiSession?.requestMeta,
-    }, definition, serverName, signal);
-
-    if (toolMeta.uiResourceUri) {
-      const sdkResult = await resultPromise;
-      signal?.throwIfAborted();
-      assertMcpStateLease(assertActive);
-      const result = asCallToolResult(sdkResult);
-      uiSession?.sendToolResult(result);
-      const mcpContent = (result.content ?? []) as McpContent[];
-      const content = transformMcpContent(mcpContent);
-
-      const mcpText = content
-        .filter((c) => c.type === "text")
-        .map((c) => (c as { text: string }).text)
-        .join("\n");
-
-      if (result.isError) {
-        let errorWithSchema = `Error: ${mcpText || "Tool execution failed"}`;
-        if (toolMeta.inputSchema) {
-          errorWithSchema += `\n\nExpected parameters:\n${formatSchema(toolMeta.inputSchema)}`;
-        }
-        return {
-          content: [{ type: "text" as const, text: errorWithSchema }],
-          details: { mode: "call", error: "tool_error", mcpResult: result },
-        };
-      }
-
-      const resultText = mcpText || "(empty result)";
-      const uiMessage = uiSession?.reused
-        ? "Updated the open UI."
-        : "📺 Interactive UI is now open in your browser. I'll respond to your prompts and intents as you interact with it.";
-      return {
-        content: [{ type: "text" as const, text: `${resultText}\n\n${uiMessage}` }],
-        details: { mode: "call", mcpResult: result, server: serverName, tool: toolMeta.originalName, uiOpen: true },
-      };
-    }
-
-    const sdkResult = await resultPromise;
-    signal?.throwIfAborted();
-    assertMcpStateLease(assertActive);
-    const result = asCallToolResult(sdkResult);
-
-    const mcpContent = (result.content ?? []) as McpContent[];
-    const content = transformMcpContent(mcpContent);
-
-    if (result.isError) {
-      const errorText = content
-        .filter((c) => c.type === "text")
-        .map((c) => (c as { text: string }).text)
-        .join("\n") || "Tool execution failed";
-
-      let errorWithSchema = `Error: ${errorText}`;
-      if (toolMeta.inputSchema) {
-        errorWithSchema += `\n\nExpected parameters:\n${formatSchema(toolMeta.inputSchema)}`;
-      }
-
-      return {
-        content: [{ type: "text" as const, text: errorWithSchema }],
-        details: { mode: "call", error: "tool_error", mcpResult: result },
-      };
-    }
-
-    return {
-      content: content.length > 0 ? content : [{ type: "text" as const, text: "(empty result)" }],
-      details: { mode: "call", mcpResult: result, server: serverName, tool: toolMeta.originalName },
-    };
-  } catch (error) {
-    await rethrowHostAbortAfterUiCancellation(signal, uiSession);
-    const message = error instanceof Error ? error.message : String(error);
-    await notifyUiCancellation(uiSession, message);
-    signal?.throwIfAborted();
-    assertMcpStateLease(assertActive);
-
-    let errorWithSchema = formatMcpToolCallFailure(error, serverName, definition.timeoutMs);
-    if (toolMeta.inputSchema) {
-      errorWithSchema += `\n\nExpected parameters:\n${formatSchema(toolMeta.inputSchema)}`;
-    }
-
-    return {
-      content: [{ type: "text" as const, text: errorWithSchema }],
-      details: { mode: "call", error: "call_failed", message },
-    };
-  } finally {
-    let staleState = false;
-    try {
-      assertMcpStateLease(assertActive);
-    } catch (error) {
-      if (error instanceof McpStateChangedError) staleState = true;
-      else throw error;
-    }
-    if (uiSession && (uiSession.reused || staleState)) {
-      uiSession.close(staleState ? "stale MCP session" : undefined);
-    }
-    state.manager.decrementInFlight(serverName);
-    if (!staleState) state.manager.touch(serverName);
-  }
-}