Function callMcpTool

packages/mcp-client/src/execution.ts:56–145

(
  options: CallToolOptions,
  deps: McpClientDependencies,
)

 * - Error wrapping for telemetry
 */
export async function callMcpTool(
  options: CallToolOptions,
  deps: McpClientDependencies,
): Promise<CallToolResult> {
  const { client, tool, args, meta, signal, onProgress, timeoutMs } = options
  const { name: serverName, client: mcpClient } = client
  const effectiveTimeout = timeoutMs ?? getMcpToolTimeoutMs()

  let progressInterval: ReturnType<typeof setInterval> | undefined

  try {
    deps.logger.debug(`[${serverName}] Calling MCP tool: ${tool}`)

    // Progress logging for long-running tools (every 30 seconds)
    progressInterval = setInterval(() => {
      deps.logger.debug(`[${serverName}] Tool '${tool}' still running`)
    }, 30_000)

    const result = await Promise.race([
      mcpClient.callTool(
        {
          name: tool,
          arguments: args,
          _meta: meta,
        },
        CallToolResultSchema,
        {
          signal,
          timeout: effectiveTimeout,
          onprogress: onProgress,
        },
      ),
      createTimeoutPromise(serverName, tool, effectiveTimeout),
    ])

    // Handle isError in result
    if ('isError' in result && result.isError) {
      let errorDetails = 'Unknown error'
      if (
        'content' in result &&
        Array.isArray(result.content) &&
        result.content.length > 0
      ) {
        const firstContent = result.content[0]
        if (
          firstContent &&
          typeof firstContent === 'object' &&
          'text' in firstContent
        ) {
          errorDetails = (firstContent as { text: string }).text
        }
      }

      throw new McpToolCallError(serverName, tool, errorDetails)
    }

    return {
      content: result,