@mcpjam/inspector 0.9.3 → 0.9.4

package/dist/server/index.js

@@ -647,10 +647,24 @@ import { Agent } from "@mastra/core/agent";
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createOllama } from "ollama-ai-provider";
-import { MCPClient as MCPClient2 } from "@mastra/mcp";
 import { TextEncoder as TextEncoder2 } from "util";
-var chat = new Hono5();
+
+// ../client/src/lib/chat-utils.ts
+function getDefaultTemperatureByProvider(provider) {
+  switch (provider) {
+    case "openai":
+      return 1;
+    case "anthropic":
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+// routes/mcp/chat.ts
 var DEBUG_ENABLED = process.env.MCP_DEBUG !== "false";
+var ELICITATION_TIMEOUT = 3e5;
+var MAX_AGENT_STEPS = 10;
 var dbg = (...args) => {
   if (DEBUG_ENABLED) console.log("[mcp/chat]", ...args);
 };
@@ -659,6 +673,287 @@ try {
 } catch {
 }
 var pendingElicitations2 = /* @__PURE__ */ new Map();
+var chat = new Hono5();
+var createLlmModel = (modelDefinition, apiKey, ollamaBaseUrl) => {
+  if (!modelDefinition?.id || !modelDefinition?.provider) {
+    throw new Error(
+      `Invalid model definition: ${JSON.stringify(modelDefinition)}`
+    );
+  }
+  switch (modelDefinition.provider) {
+    case "anthropic":
+      return createAnthropic({ apiKey })(modelDefinition.id);
+    case "openai":
+      return createOpenAI({ apiKey })(modelDefinition.id);
+    case "deepseek":
+      return createOpenAI({ apiKey, baseURL: "https://api.deepseek.com/v1" })(
+        modelDefinition.id
+      );
+    case "ollama":
+      const baseUrl = ollamaBaseUrl || "http://localhost:11434";
+      return createOllama({
+        baseURL: `${baseUrl}`
+      })(modelDefinition.id, {
+        simulateStreaming: true
+      });
+    default:
+      throw new Error(
+        `Unsupported provider: ${modelDefinition.provider} for model: ${modelDefinition.id}`
+      );
+  }
+};
+var createElicitationHandler = (streamingContext) => {
+  return async (elicitationRequest) => {
+    const requestId = `elicit_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    if (streamingContext.controller && streamingContext.encoder) {
+      streamingContext.controller.enqueue(
+        streamingContext.encoder.encode(
+          `data: ${JSON.stringify({
+            type: "elicitation_request",
+            requestId,
+            message: elicitationRequest.message,
+            schema: elicitationRequest.requestedSchema,
+            timestamp: /* @__PURE__ */ new Date()
+          })}
+
+`
+        )
+      );
+    }
+    return new Promise((resolve, reject) => {
+      pendingElicitations2.set(requestId, { resolve, reject });
+      setTimeout(() => {
+        if (pendingElicitations2.has(requestId)) {
+          pendingElicitations2.delete(requestId);
+          reject(new Error("Elicitation timeout"));
+        }
+      }, ELICITATION_TIMEOUT);
+    });
+  };
+};
+var wrapToolsWithStreaming = (tools2, streamingContext) => {
+  const wrappedTools = {};
+  for (const [name, tool] of Object.entries(tools2)) {
+    wrappedTools[name] = {
+      ...tool,
+      execute: async (params) => {
+        const currentToolCallId = ++streamingContext.toolCallId;
+        const startedAt = Date.now();
+        if (streamingContext.controller && streamingContext.encoder) {
+          streamingContext.controller.enqueue(
+            streamingContext.encoder.encode(
+              `data: ${JSON.stringify({
+                type: "tool_call",
+                toolCall: {
+                  id: currentToolCallId,
+                  name,
+                  parameters: params,
+                  timestamp: /* @__PURE__ */ new Date(),
+                  status: "executing"
+                }
+              })}
+
+`
+            )
+          );
+        }
+        dbg("Tool executing", { name, currentToolCallId, params });
+        try {
+          const result = await tool.execute(params);
+          dbg("Tool result", {
+            name,
+            currentToolCallId,
+            ms: Date.now() - startedAt
+          });
+          if (streamingContext.controller && streamingContext.encoder) {
+            streamingContext.controller.enqueue(
+              streamingContext.encoder.encode(
+                `data: ${JSON.stringify({
+                  type: "tool_result",
+                  toolResult: {
+                    id: currentToolCallId,
+                    toolCallId: currentToolCallId,
+                    result,
+                    timestamp: /* @__PURE__ */ new Date()
+                  }
+                })}
+
+`
+              )
+            );
+          }
+          return result;
+        } catch (error) {
+          dbg("Tool error", {
+            name,
+            currentToolCallId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          if (streamingContext.controller && streamingContext.encoder) {
+            streamingContext.controller.enqueue(
+              streamingContext.encoder.encode(
+                `data: ${JSON.stringify({
+                  type: "tool_result",
+                  toolResult: {
+                    id: currentToolCallId,
+                    toolCallId: currentToolCallId,
+                    error: error instanceof Error ? error.message : String(error),
+                    timestamp: /* @__PURE__ */ new Date()
+                  }
+                })}
+
+`
+              )
+            );
+          }
+          throw error;
+        }
+      }
+    };
+  }
+  return wrappedTools;
+};
+var handleAgentStepFinish = (streamingContext, text, toolCalls, toolResults) => {
+  try {
+    if (toolCalls && Array.isArray(toolCalls)) {
+      for (const call of toolCalls) {
+        const currentToolCallId = ++streamingContext.toolCallId;
+        streamingContext.lastEmittedToolCallId = currentToolCallId;
+        if (streamingContext.controller && streamingContext.encoder) {
+          streamingContext.controller.enqueue(
+            streamingContext.encoder.encode(
+              `data: ${JSON.stringify({
+                type: "tool_call",
+                toolCall: {
+                  id: currentToolCallId,
+                  name: call.name || call.toolName,
+                  parameters: call.params || call.args || {},
+                  timestamp: /* @__PURE__ */ new Date(),
+                  status: "executing"
+                }
+              })}
+
+`
+            )
+          );
+        }
+      }
+    }
+    if (toolResults && Array.isArray(toolResults)) {
+      for (const result of toolResults) {
+        const currentToolCallId = streamingContext.lastEmittedToolCallId != null ? streamingContext.lastEmittedToolCallId : ++streamingContext.toolCallId;
+        if (streamingContext.controller && streamingContext.encoder) {
+          streamingContext.controller.enqueue(
+            streamingContext.encoder.encode(
+              `data: ${JSON.stringify({
+                type: "tool_result",
+                toolResult: {
+                  id: currentToolCallId,
+                  toolCallId: currentToolCallId,
+                  result: result.result,
+                  error: result.error,
+                  timestamp: /* @__PURE__ */ new Date()
+                }
+              })}
+
+`
+            )
+          );
+        }
+      }
+    }
+  } catch (err) {
+    dbg("onStepFinish error", err);
+  }
+};
+var streamAgentResponse = async (streamingContext, stream) => {
+  let hasContent = false;
+  let chunkCount = 0;
+  for await (const chunk of stream.textStream) {
+    if (chunk && chunk.trim()) {
+      hasContent = true;
+      chunkCount++;
+      streamingContext.controller.enqueue(
+        streamingContext.encoder.encode(
+          `data: ${JSON.stringify({ type: "text", content: chunk })}
+
+`
+        )
+      );
+    }
+  }
+  dbg("Streaming finished", { hasContent, chunkCount });
+  return { hasContent, chunkCount };
+};
+var fallbackToCompletion = async (agent, messages, streamingContext, provider) => {
+  try {
+    const result = await agent.generate(messages, {
+      temperature: getDefaultTemperatureByProvider(provider)
+    });
+    if (result.text && result.text.trim()) {
+      streamingContext.controller.enqueue(
+        streamingContext.encoder.encode(
+          `data: ${JSON.stringify({
+            type: "text",
+            content: result.text
+          })}
+
+`
+        )
+      );
+    }
+  } catch (fallbackErr) {
+    streamingContext.controller.enqueue(
+      streamingContext.encoder.encode(
+        `data: ${JSON.stringify({
+          type: "text",
+          content: "Failed to generate response. Please try again. ",
+          error: fallbackErr instanceof Error ? fallbackErr.message : "Unknown error"
+        })}
+
+`
+      )
+    );
+  }
+};
+var safeDisconnect = async (client) => {
+  if (client) {
+    try {
+      await client.disconnect();
+    } catch (cleanupError) {
+      console.warn("[mcp/chat] Error cleaning up MCP client:", cleanupError);
+    }
+  }
+};
+var createStreamingResponse = async (agent, messages, toolsets, streamingContext, provider) => {
+  const stream = await agent.stream(messages, {
+    maxSteps: MAX_AGENT_STEPS,
+    temperature: getDefaultTemperatureByProvider(provider),
+    toolsets,
+    onStepFinish: ({ text, toolCalls, toolResults }) => {
+      handleAgentStepFinish(streamingContext, text, toolCalls, toolResults);
+    }
+  });
+  const { hasContent } = await streamAgentResponse(streamingContext, stream);
+  if (!hasContent) {
+    dbg("No content from textStream; falling back to completion");
+    await fallbackToCompletion(agent, messages, streamingContext, provider);
+  }
+  streamingContext.controller.enqueue(
+    streamingContext.encoder.encode(
+      `data: ${JSON.stringify({
+        type: "elicitation_complete"
+      })}
+
+`
+    )
+  );
+  streamingContext.controller.enqueue(
+    streamingContext.encoder.encode(`data: [DONE]
+
+`)
+  );
+};
 chat.post("/", async (c) => {
   let client = null;
   try {
@@ -666,6 +961,7 @@ chat.post("/", async (c) => {
     const {
       serverConfigs,
       model,
+      provider,
       apiKey,
       systemPrompt,
       messages,
@@ -698,7 +994,7 @@ chat.post("/", async (c) => {
       pendingElicitations2.delete(requestId);
       return c.json({ success: true });
     }
-    if (!model || !model.id || !apiKey || !messages) {
+    if (!model?.id || !apiKey || !messages) {
       return c.json(
         {
           success: false,
@@ -707,323 +1003,88 @@ chat.post("/", async (c) => {
         400
       );
     }
-    dbg("Incoming chat request", {
-      provider: model?.provider,
-      modelId: model?.id,
-      messageCount: messages?.length,
-      serverCount: serverConfigs ? Object.keys(serverConfigs).length : 0
-    });
-    if (serverConfigs && Object.keys(serverConfigs).length > 0) {
-      const validation = validateMultipleServerConfigs(serverConfigs);
-      if (!validation.success) {
-        dbg("Server config validation failed", validation.errors || validation.error);
-        return c.json(
-          {
-            success: false,
-            error: validation.error.message,
-            details: validation.errors
-          },
-          validation.error.status
-        );
-      }
-      client = createMCPClientWithMultipleConnections(validation.validConfigs);
-      dbg("Created MCP client with servers", Object.keys(validation.validConfigs));
-    } else {
-      client = new MCPClient2({
-        id: `chat-${Date.now()}`,
-        servers: {}
-      });
-      dbg("Created MCP client without servers");
+    if (!serverConfigs || Object.keys(serverConfigs).length === 0) {
+      return c.json(
+        {
+          success: false,
+          error: "No server configs provided"
+        },
+        400
+      );
     }
-    const llmModel = getLlmModel(model, apiKey, ollamaBaseUrl);
-    dbg("LLM model initialized", { provider: model.provider, id: model.id });
-    let toolCallId = 0;
-    let streamController = null;
-    let encoder = null;
-    let lastEmittedToolCallId = null;
-    const elicitationHandler = async (elicitationRequest) => {
-      const requestId2 = `elicit_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-      if (streamController && encoder) {
-        streamController.enqueue(
-          encoder.encode(
-            `data: ${JSON.stringify({
-              type: "elicitation_request",
-              requestId: requestId2,
-              message: elicitationRequest.message,
-              schema: elicitationRequest.requestedSchema,
-              timestamp: /* @__PURE__ */ new Date()
-            })}
-
-`
-          )
-        );
-      }
-      dbg("Elicitation requested", { requestId: requestId2 });
-      return new Promise((resolve, reject) => {
-        pendingElicitations2.set(requestId2, { resolve, reject });
-        setTimeout(() => {
-          if (pendingElicitations2.has(requestId2)) {
-            pendingElicitations2.delete(requestId2);
-            reject(new Error("Elicitation timeout"));
-          }
-        }, 3e5);
-      });
-    };
-    if (client.elicitation && client.elicitation.onRequest && serverConfigs) {
-      for (const serverName of Object.keys(serverConfigs)) {
-        const normalizedName = serverName.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
-        client.elicitation.onRequest(normalizedName, elicitationHandler);
-        dbg("Registered elicitation handler", { serverName, normalizedName });
-      }
+    const validation = validateMultipleServerConfigs(serverConfigs);
+    if (!validation.success) {
+      dbg(
+        "Server config validation failed",
+        validation.errors || validation.error
+      );
+      return c.json(
+        {
+          success: false,
+          error: validation.error.message,
+          details: validation.errors
+        },
+        validation.error.status
+      );
     }
+    client = createMCPClientWithMultipleConnections(validation.validConfigs);
+    const llmModel = createLlmModel(model, apiKey, ollamaBaseUrl);
     const tools2 = await client.getTools();
-    const originalTools = tools2 && Object.keys(tools2).length > 0 ? tools2 : {};
-    const wrappedTools = {};
-    for (const [name, tool] of Object.entries(originalTools)) {
-      wrappedTools[name] = {
-        ...tool,
-        execute: async (params) => {
-          const currentToolCallId = ++toolCallId;
-          const startedAt = Date.now();
-          if (streamController && encoder) {
-            streamController.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "tool_call",
-                  toolCall: {
-                    id: currentToolCallId,
-                    name,
-                    parameters: params,
-                    timestamp: /* @__PURE__ */ new Date(),
-                    status: "executing"
-                  }
-                })}
-
-`
-              )
-            );
-          }
-          dbg("Tool executing", { name, currentToolCallId, params });
-          try {
-            const result = await tool.execute(params);
-            dbg("Tool result", { name, currentToolCallId, ms: Date.now() - startedAt });
-            if (streamController && encoder) {
-              streamController.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({
-                    type: "tool_result",
-                    toolResult: {
-                      id: currentToolCallId,
-                      toolCallId: currentToolCallId,
-                      result,
-                      timestamp: /* @__PURE__ */ new Date()
-                    }
-                  })}
-
-`
-                )
-              );
-            }
-            return result;
-          } catch (error) {
-            dbg("Tool error", { name, currentToolCallId, error: error instanceof Error ? error.message : String(error) });
-            if (streamController && encoder) {
-              streamController.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({
-                    type: "tool_result",
-                    toolResult: {
-                      id: currentToolCallId,
-                      toolCallId: currentToolCallId,
-                      error: error instanceof Error ? error.message : String(error),
-                      timestamp: /* @__PURE__ */ new Date()
-                    }
-                  })}
-
-`
-                )
-              );
-            }
-            throw error;
-          }
-        }
-      };
-    }
     const agent = new Agent({
       name: "MCP Chat Agent",
       instructions: systemPrompt || "You are a helpful assistant with access to MCP tools.",
       model: llmModel,
-      tools: Object.keys(wrappedTools).length > 0 ? wrappedTools : void 0
+      tools: void 0
+      // Start without tools, add them in streaming context
     });
     const formattedMessages = messages.map((msg) => ({
       role: msg.role,
       content: msg.content
     }));
-    const toolsets = serverConfigs ? await client.getToolsets() : void 0;
+    const toolsets = await client.getToolsets();
     dbg("Streaming start", {
-      toolsetServers: toolsets ? Object.keys(toolsets) : [],
+      toolsetServers: Object.keys(toolsets),
       messageCount: formattedMessages.length
     });
-    let streamedAnyText = false;
-    const stream = await agent.stream(formattedMessages, {
-      maxSteps: 10,
-      // Allow up to 10 steps for tool usage
-      toolsets,
-      onStepFinish: ({ text, toolCalls, toolResults }) => {
-        try {
-          if (text && streamController && encoder) {
-            streamedAnyText = true;
-            streamController.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({ type: "text", content: text })}
-
-`
-              )
-            );
-          }
-          const tcList = toolCalls;
-          if (tcList && Array.isArray(tcList)) {
-            for (const call of tcList) {
-              const currentToolCallId = ++toolCallId;
-              lastEmittedToolCallId = currentToolCallId;
-              if (streamController && encoder) {
-                streamController.enqueue(
-                  encoder.encode(
-                    `data: ${JSON.stringify({
-                      type: "tool_call",
-                      toolCall: {
-                        id: currentToolCallId,
-                        name: call.name || call.toolName,
-                        parameters: call.params || call.args || {},
-                        timestamp: /* @__PURE__ */ new Date(),
-                        status: "executing"
-                      }
-                    })}
-
-`
-                  )
-                );
-              }
-            }
-          }
-          const trList = toolResults;
-          if (trList && Array.isArray(trList)) {
-            for (const result of trList) {
-              const currentToolCallId = lastEmittedToolCallId != null ? lastEmittedToolCallId : ++toolCallId;
-              if (streamController && encoder) {
-                streamController.enqueue(
-                  encoder.encode(
-                    `data: ${JSON.stringify({
-                      type: "tool_result",
-                      toolResult: {
-                        id: currentToolCallId,
-                        toolCallId: currentToolCallId,
-                        result: result.result,
-                        error: result.error,
-                        timestamp: /* @__PURE__ */ new Date()
-                      }
-                    })}
-
-`
-                  )
-                );
-              }
-            }
+    const encoder = new TextEncoder2();
+    const readableStream = new ReadableStream({
+      async start(controller) {
+        const streamingContext = {
+          controller,
+          encoder,
+          toolCallId: 0,
+          lastEmittedToolCallId: null
+        };
+        const streamingWrappedTools = wrapToolsWithStreaming(
+          tools2,
+          streamingContext
+        );
+        const streamingAgent = new Agent({
+          name: agent.name,
+          instructions: agent.instructions,
+          model: agent.model,
+          tools: Object.keys(streamingWrappedTools).length > 0 ? streamingWrappedTools : void 0
+        });
+        if (client?.elicitation?.onRequest) {
+          for (const serverName of Object.keys(serverConfigs)) {
+            const normalizedName = normalizeServerConfigName(serverName);
+            const elicitationHandler = createElicitationHandler(streamingContext);
+            client.elicitation.onRequest(normalizedName, elicitationHandler);
           }
-        } catch (err) {
-          dbg("onStepFinish error", err);
         }
-      },
-      onFinish: ({ text, finishReason }) => {
-        dbg("onFinish called", { finishReason, hasText: Boolean(text) });
         try {
-          if (text && streamController && encoder) {
-            streamedAnyText = true;
-            streamController.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({ type: "text", content: text })}
-
-`
-              )
+          if (client) {
+            await createStreamingResponse(
+              streamingAgent,
+              formattedMessages,
+              toolsets,
+              streamingContext,
+              provider
             );
+          } else {
+            throw new Error("MCP client is null");
           }
-        } catch (err) {
-          dbg("onFinish enqueue error", err);
-        }
-      }
-    });
-    encoder = new TextEncoder2();
-    const readableStream = new ReadableStream({
-      async start(controller) {
-        streamController = controller;
-        try {
-          let hasContent = false;
-          let chunkCount = 0;
-          for await (const chunk of stream.textStream) {
-            if (chunk && chunk.trim()) {
-              hasContent = true;
-              chunkCount++;
-              controller.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({ type: "text", content: chunk })}
-
-`
-                )
-              );
-            }
-          }
-          dbg("Streaming finished", { hasContent, chunkCount });
-          if (!hasContent && !streamedAnyText) {
-            dbg("No content from textStream/callbacks; falling back to generate()");
-            try {
-              const gen = await agent.generate(formattedMessages, {
-                maxSteps: 10,
-                toolsets
-              });
-              const finalText = gen.text || "";
-              if (finalText) {
-                controller.enqueue(
-                  encoder.encode(
-                    `data: ${JSON.stringify({ type: "text", content: finalText })}
-
-`
-                  )
-                );
-              } else {
-                dbg("generate() also returned empty text");
-                controller.enqueue(
-                  encoder.encode(
-                    `data: ${JSON.stringify({ type: "text", content: "I apologize, but I couldn't generate a response. Please try again." })}
-
-`
-                  )
-                );
-              }
-            } catch (fallbackErr) {
-              console.error("[mcp/chat] Fallback generate() error:", fallbackErr);
-              controller.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({ type: "error", error: fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr) })}
-
-`
-                )
-              );
-            }
-          }
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({
-                type: "elicitation_complete"
-              })}
-
-`
-            )
-          );
-          controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
         } catch (error) {
-          console.error("[mcp/chat] Streaming error:", error);
           controller.enqueue(
             encoder.encode(
               `data: ${JSON.stringify({
@@ -1035,16 +1096,7 @@ chat.post("/", async (c) => {
             )
           );
         } finally {
-          if (client) {
-            try {
-              await client.disconnect();
-            } catch (cleanupError) {
-              console.warn(
-                "[mcp/chat] Error cleaning up MCP client after streaming:",
-                cleanupError
-              );
-            }
-          }
+          await safeDisconnect(client);
           controller.close();
         }
       }
@@ -1058,13 +1110,7 @@ chat.post("/", async (c) => {
     });
   } catch (error) {
     console.error("[mcp/chat] Error in chat API:", error);
-    if (client) {
-      try {
-        await client.disconnect();
-      } catch (cleanupError) {
-        console.warn("Error cleaning up MCP client after error:", cleanupError);
-      }
-    }
+    await safeDisconnect(client);
     return c.json(
       {
         success: false,
@@ -1074,32 +1120,6 @@ chat.post("/", async (c) => {
     );
   }
 });
-var getLlmModel = (modelDefinition, apiKey, ollamaBaseUrl) => {
-  if (!modelDefinition || !modelDefinition.id || !modelDefinition.provider) {
-    throw new Error(
-      `Invalid model definition: ${JSON.stringify(modelDefinition)}`
-    );
-  }
-  switch (modelDefinition.provider) {
-    case "anthropic":
-      return createAnthropic({ apiKey })(modelDefinition.id);
-    case "openai":
-      return createOpenAI({ apiKey })(modelDefinition.id);
-    case "ollama":
-      const baseUrl = ollamaBaseUrl || "http://localhost:11434";
-      return createOllama({
-        // The provider expects the root Ollama URL; it internally targets the /api endpoints
-        baseURL: `${baseUrl}`
-      })(modelDefinition.id, {
-        simulateStreaming: true
-        // Enable streaming for Ollama models
-      });
-    default:
-      throw new Error(
-        `Unsupported provider: ${modelDefinition.provider} for model: ${modelDefinition.id}`
-      );
-  }
-};
 var chat_default = chat;
 
 // routes/mcp/oauth.ts