File size: 3,649 Bytes
e67ab0e 99156e4 1d3e986 99156e4 e67ab0e 7b56bb5 e67ab0e cc316dd e67ab0e cc316dd e67ab0e 1d3e986 e67ab0e 99156e4 cc316dd 99156e4 e67ab0e 99156e4 0ab931d 99156e4 e67ab0e |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 |
import { Client } from "@modelcontextprotocol/sdk/client";
import { getClient, evictFromPool } from "./clientPool";
import { isExaServer, getExaApiKey, callExaDirectApi } from "./exaDirect";
function isConnectionClosedError(err: unknown): boolean {
const message = err instanceof Error ? err.message : String(err);
return message.includes("-32000") || message.toLowerCase().includes("connection closed");
}
export interface McpServerConfig {
name: string;
url: string;
headers?: Record<string, string>;
}
const DEFAULT_TIMEOUT_MS = 60_000;
export type McpToolTextResponse = {
text: string;
/** If the server returned structuredContent, include it raw */
structured?: unknown;
/** Raw content blocks returned by the server, if any */
content?: unknown[];
};
export type McpToolProgress = {
progress: number;
total?: number;
message?: string;
};
export async function callMcpTool(
server: McpServerConfig,
tool: string,
args: unknown = {},
{
timeoutMs = DEFAULT_TIMEOUT_MS,
signal,
client,
onProgress,
}: {
timeoutMs?: number;
signal?: AbortSignal;
client?: Client;
onProgress?: (progress: McpToolProgress) => void;
} = {}
): Promise<McpToolTextResponse> {
// Bypass MCP protocol for Exa - call direct API
if (isExaServer(server)) {
const apiKey = getExaApiKey(server);
if (!apiKey) {
throw new Error(
"Exa API key not found. Set EXA_API_KEY environment variable or add ?exaApiKey= to the server URL."
);
}
const normalizedArgs =
typeof args === "object" && args !== null && !Array.isArray(args)
? (args as Record<string, unknown>)
: {};
return callExaDirectApi(tool, normalizedArgs, apiKey, { signal, timeoutMs });
}
const normalizedArgs =
typeof args === "object" && args !== null && !Array.isArray(args)
? (args as Record<string, unknown>)
: undefined;
// Get a (possibly pooled) client. The client itself was connected with a signal
// that already composes outer cancellation. We still enforce a per-call timeout here.
let activeClient = client ?? (await getClient(server, signal));
const callToolOptions = {
signal,
timeout: timeoutMs,
// Enable progress tokens so long-running tools keep extending the timeout.
onprogress: (progress: McpToolProgress) => {
onProgress?.({
progress: progress.progress,
total: progress.total,
message: progress.message,
});
},
resetTimeoutOnProgress: true,
};
let response;
try {
response = await activeClient.callTool(
{ name: tool, arguments: normalizedArgs },
undefined,
callToolOptions
);
} catch (err) {
if (!isConnectionClosedError(err)) {
throw err;
}
// Evict stale client and close it
const stale = evictFromPool(server);
stale?.close?.().catch(() => {});
// Retry with fresh client
activeClient = await getClient(server, signal);
response = await activeClient.callTool(
{ name: tool, arguments: normalizedArgs },
undefined,
callToolOptions
);
}
const parts = Array.isArray(response?.content) ? (response.content as Array<unknown>) : [];
const textParts = parts
.filter((part): part is { type: "text"; text: string } => {
if (typeof part !== "object" || part === null) return false;
const obj = part as Record<string, unknown>;
return obj["type"] === "text" && typeof obj["text"] === "string";
})
.map((p) => p.text);
const text = textParts.join("\n");
const structured = (response as unknown as { structuredContent?: unknown })?.structuredContent;
const contentBlocks = Array.isArray(response?.content)
? (response.content as unknown[])
: undefined;
return { text, structured, content: contentBlocks };
}
|