Improve MCP tool handling and OpenAI integration

Refactors MCP tool listing and invocation for better type safety and normalization. Enhances OpenAI chat completion streaming with stricter typing, improved multimodal support, and more robust tool call aggregation. Cleans up type definitions and utility functions for message updates. Fixes minor bugs and improves code clarity throughout MCP and text generation modules.

Author: gary149

src/hooks.server.ts

@@ -34,9 +34,9 @@ export const init: ServerInit = async () => {
 			);
 		}
 
-			logger.info("Starting server...");
-			initExitHandler();
-			loadMcpServersOnStartup();
+		logger.info("Starting server...");
+		initExitHandler();
+		loadMcpServersOnStartup();
 
 		checkAndRunMigrations();
 		refreshConversationStats();

src/lib/components/chat/ToolUpdate.svelte

@@ -23,7 +23,8 @@
 	let toolDone = $derived(tool.some(isMessageToolResultUpdate));
 	let eta = $derived(tool.find((update) => update.subtype === MessageToolUpdateType.ETA)?.eta);
 
-	const availableTools: ToolFront[] = (page.data as any)?.tools ?? [];
+	const toolsData = page.data as { tools?: ToolFront[] } | undefined;
+	const availableTools: ToolFront[] = toolsData?.tools ?? [];
 
 	let loadingBarEl: HTMLDivElement | undefined = $state();
 	let animation: Animation | undefined = $state();

src/lib/server/mcp/httpClient.ts

@@ -30,6 +30,11 @@ export async function callMcpTool(
 	const client = new Client({ name: "chat-ui-mcp", version: "0.1.0" });
 	const url = toUrl(server.url);
 
+	const normalizedArgs =
+		typeof args === "object" && args !== null && !Array.isArray(args)
+			? (args as Record<string, unknown>)
+			: undefined;
+
 	async function connectStreamable() {
 		const transport = new StreamableHTTPClientTransport(url, {
 			requestInit: { headers: server.headers },
@@ -53,19 +58,24 @@ export async function callMcpTool(
 			usingSse = true;
 		}
 
-		const runTool = async () => client.callTool({ name: tool, arguments: args });
+		const runTool = async () => client.callTool({ name: tool, arguments: normalizedArgs });
+		type CallToolResult = Awaited<ReturnType<typeof runTool>>;
 
 		const raceWithTimeout = <T>(promise: Promise<T>) =>
 			Promise.race([
 				promise,
 				new Promise<never>((_, reject) => {
-					controller.signal.addEventListener("abort", () => reject(new Error("MCP tool call timed out")), {
-						once: true,
-					});
+					controller.signal.addEventListener(
+						"abort",
+						() => reject(new Error("MCP tool call timed out")),
+						{
+							once: true,
+						}
+					);
 				}),
 			]);
 
-		let response: Awaited<ReturnType<typeof runTool>>;
+		let response: CallToolResult;
 		try {
 			response = await raceWithTimeout(runTool());
 		} catch (error) {
@@ -80,10 +90,14 @@ export async function callMcpTool(
 			response = await raceWithTimeout(runTool());
 		}
 
-		const parts = Array.isArray(response?.content) ? response.content : [];
+		const parts = Array.isArray(response?.content) ? (response.content as Array<unknown>) : [];
 		const textParts = parts
-			.filter((part: any) => part?.type === "text" && typeof part.text === "string")
-			.map((part: any) => part.text as string);
+			.filter((part): part is { type: "text"; text: string } => {
+				if (typeof part !== "object" || part === null) return false;
+				const candidate = part as { type?: unknown; text?: unknown };
+				return candidate.type === "text" && typeof candidate.text === "string";
+			})
+			.map((part) => part.text);
 
 		if (textParts.length > 0) {
 			return textParts.join("\n");

src/lib/server/mcp/registry.ts

@@ -24,11 +24,10 @@ function parseServers(raw: string): McpServerConfig[] {
 				const headersRaw = (entry as Record<string, unknown>).headers;
 				let headers: Record<string, string> | undefined;
 				if (headersRaw && typeof headersRaw === "object" && !Array.isArray(headersRaw)) {
-					headers = Object.fromEntries(
-						Object.entries(headersRaw as Record<string, unknown>).filter(
-							([, value]): value is string => typeof value === "string"
-						)
+					const headerEntries = Object.entries(headersRaw as Record<string, unknown>).filter(
+						(entry): entry is [string, string] => typeof entry[1] === "string"
 					);
+					headers = Object.fromEntries(headerEntries);
 				}
 
 				return headers ? { name, url, headers } : { name, url };

src/lib/server/mcp/tools.ts

@@ -32,7 +32,14 @@ function sanitizeName(name: string) {
 	return name.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 64);
 }
 
-async function listServerTools(server: McpServerConfig) {
+type ListedTool = {
+	name?: string;
+	inputSchema?: Record<string, unknown>;
+	description?: string;
+	annotations?: { title?: string };
+};
+
+async function listServerTools(server: McpServerConfig): Promise<ListedTool[]> {
 	const url = new URL(server.url);
 	const client = new Client({ name: "chat-ui-mcp", version: "0.1.0" });
 	try {
@@ -49,7 +56,7 @@ async function listServerTools(server: McpServerConfig) {
 		}
 
 		const response = await client.listTools({});
-		return Array.isArray(response?.tools) ? response.tools : [];
+		return Array.isArray(response?.tools) ? (response.tools as ListedTool[]) : [];
 	} finally {
 		try {
 			await client.close?.();
@@ -71,59 +78,64 @@ export async function getOpenAiToolsForMcp(
 	const tools: OpenAiTool[] = [];
 	const mapping: Record<string, McpToolMapping> = {};
 
-  const seenNames = new Set<string>();
-
-  const pushToolDefinition = (
-    name: string,
-    description: string | undefined,
-    parameters: Record<string, unknown> | undefined,
-  ) => {
-    if (seenNames.has(name)) return;
-    tools.push({
-      type: "function",
-      function: {
-        name,
-        description,
-        parameters,
-      },
-    });
-    seenNames.add(name);
-  };
-
-  for (const server of servers) {
-    try {
-      const serverTools = await listServerTools(server);
-      for (const tool of serverTools as any[]) {
-        const parameters =
-          tool.inputSchema && typeof tool.inputSchema === "object" ? tool.inputSchema : undefined;
-        const description = tool.description ?? tool?.annotations?.title;
-
-        const primaryName = sanitizeName(`${server.name}.${tool.name}`);
-        pushToolDefinition(primaryName, description, parameters);
-        mapping[primaryName] = {
-          fnName: primaryName,
-          server: server.name,
-          tool: tool.name,
-        };
-
-        const plainName = sanitizeName(tool.name);
-        if (!(plainName in mapping)) {
-          pushToolDefinition(plainName, description, parameters);
-          mapping[plainName] = {
-            fnName: plainName,
-            server: server.name,
-            tool: tool.name,
-          };
-        }
-      }
-    } catch {
-      // Ignore individual server failures
-      continue;
-    }
-  }
-
-  cache = { fetchedAt: now, ttlMs, tools, mapping };
-  return { tools, mapping };
+	const seenNames = new Set<string>();
+
+	const pushToolDefinition = (
+		name: string,
+		description: string | undefined,
+		parameters: Record<string, unknown> | undefined
+	) => {
+		if (seenNames.has(name)) return;
+		tools.push({
+			type: "function",
+			function: {
+				name,
+				description,
+				parameters,
+			},
+		});
+		seenNames.add(name);
+	};
+
+	for (const server of servers) {
+		try {
+			const serverTools = await listServerTools(server);
+			for (const tool of serverTools) {
+				if (typeof tool.name !== "string" || tool.name.trim().length === 0) {
+					continue;
+				}
+
+				const parameters =
+					tool.inputSchema && typeof tool.inputSchema === "object" ? tool.inputSchema : undefined;
+				const description = tool.description ?? tool.annotations?.title;
+				const toolName = tool.name;
+
+				const primaryName = sanitizeName(`${server.name}.${toolName}`);
+				pushToolDefinition(primaryName, description, parameters);
+				mapping[primaryName] = {
+					fnName: primaryName,
+					server: server.name,
+					tool: toolName,
+				};
+
+				const plainName = sanitizeName(toolName);
+				if (!(plainName in mapping)) {
+					pushToolDefinition(plainName, description, parameters);
+					mapping[plainName] = {
+						fnName: plainName,
+						server: server.name,
+						tool: toolName,
+					};
+				}
+			}
+		} catch {
+			// Ignore individual server failures
+			continue;
+		}
+	}
+
+	cache = { fetchedAt: now, ttlMs, tools, mapping };
+	return { tools, mapping };
 }
 
 export function resetMcpToolsCache() {