@mcpjam/inspector 1.0.20 → 1.0.22

package/dist/server/index.js

@@ -39,7 +39,7 @@ import * as Sentry2 from "@sentry/node";
 import { serve } from "@hono/node-server";
 import dotenv from "dotenv";
 import fixPath from "fix-path";
-import { Hono as Hono13 } from "hono";
+import { Hono as Hono15 } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
@@ -885,7 +885,7 @@ var MCPClientManager = class {
 };
 
 // routes/mcp/index.ts
-import { Hono as Hono12 } from "hono";
+import { Hono as Hono14 } from "hono";
 
 // routes/mcp/connect.ts
 import { Hono } from "hono";
@@ -1472,7 +1472,8 @@ resources.post("/widget/store", async (c) => {
       toolInput,
       toolOutput,
       toolResponseMetadata,
-      toolId
+      toolId,
+      theme
     } = body;
     if (!serverId || !uri || !toolId) {
       return c.json({ success: false, error: "Missing required fields" }, 400);
@@ -1484,6 +1485,7 @@ resources.post("/widget/store", async (c) => {
       toolOutput,
       toolResponseMetadata: toolResponseMetadata ?? null,
       toolId,
+      theme: theme ?? "dark",
       timestamp: Date.now()
     });
     return c.json({ success: true });
@@ -1544,7 +1546,14 @@ resources.get("/widget-content/:toolId", async (c) => {
         404
       );
     }
-    const { serverId, uri, toolInput, toolOutput, toolResponseMetadata } = widgetData;
+    const {
+      serverId,
+      uri,
+      toolInput,
+      toolOutput,
+      toolResponseMetadata,
+      theme
+    } = widgetData;
     const mcpClientManager2 = c.mcpClientManager;
     const availableServers = mcpClientManager2.listServers().filter((id) => Boolean(mcpClientManager2.getClient(id)));
     let actualServerId = serverId;
@@ -1604,10 +1613,13 @@ resources.get("/widget-content/:toolId", async (c) => {
             toolResponseMetadata: ${JSON.stringify(toolResponseMetadata ?? null)},
             displayMode: 'inline',
             maxHeight: 600,
-            theme: 'dark',
+            theme: ${JSON.stringify(theme ?? "dark")},
             locale: 'en-US',
             safeArea: { insets: { top: 0, bottom: 0, left: 0, right: 0 } },
-            userAgent: {},
+            userAgent: {
+              device: { type: 'desktop' },
+              capabilities: { hover: true, touch: false }
+            },
             widgetState: null,
 
             async setWidgetState(state) {
@@ -1731,6 +1743,28 @@ resources.get("/widget-content/:toolId", async (c) => {
               }
             } catch (err) {}
           }, 0);
+
+          // Listen for theme changes from parent
+          window.addEventListener('message', (event) => {
+            if (event.data.type === 'webplus:set_globals') {
+              const { globals } = event.data;
+
+              // Update theme if provided
+              if (globals?.theme && window.openai) {
+                window.openai.theme = globals.theme;
+
+                // Dispatch event for widgets that use useTheme() hook
+                try {
+                  const globalsEvent = new CustomEvent('webplus:set_globals', {
+                    detail: { globals: { theme: globals.theme } }
+                  });
+                  window.dispatchEvent(globalsEvent);
+                } catch (err) {
+                  console.error('[OpenAI Widget] Failed to dispatch theme change:', err);
+                }
+              }
+            }
+          });
         })();
       </script>
     `;
@@ -1875,224 +1909,6 @@ var MCPJAM_PROVIDED_MODEL_IDS = [
 var isMCPJamProvidedModel = (modelId) => {
   return MCPJAM_PROVIDED_MODEL_IDS.includes(modelId);
 };
-var Model = /* @__PURE__ */ ((Model2) => {
-  Model2["CLAUDE_OPUS_4_0"] = "claude-opus-4-0";
-  Model2["CLAUDE_SONNET_4_0"] = "claude-sonnet-4-0";
-  Model2["CLAUDE_3_7_SONNET_LATEST"] = "claude-3-7-sonnet-latest";
-  Model2["CLAUDE_3_5_SONNET_LATEST"] = "claude-3-5-sonnet-latest";
-  Model2["CLAUDE_3_5_HAIKU_LATEST"] = "claude-3-5-haiku-latest";
-  Model2["GPT_4_1"] = "gpt-4.1";
-  Model2["GPT_4_1_MINI"] = "gpt-4.1-mini";
-  Model2["GPT_4_1_NANO"] = "gpt-4.1-nano";
-  Model2["GPT_4O"] = "gpt-4o";
-  Model2["GPT_4O_MINI"] = "gpt-4o-mini";
-  Model2["GPT_4_TURBO"] = "gpt-4-turbo";
-  Model2["GPT_4"] = "gpt-4";
-  Model2["GPT_5"] = "gpt-5";
-  Model2["GPT_5_MINI"] = "gpt-5-mini";
-  Model2["GPT_5_NANO"] = "gpt-5-nano";
-  Model2["GPT_5_MAIN"] = "openai/gpt-5";
-  Model2["GPT_5_PRO"] = "gpt-5-pro";
-  Model2["GPT_5_CODEX"] = "gpt-5-codex";
-  Model2["GPT_3_5_TURBO"] = "gpt-3.5-turbo";
-  Model2["DEEPSEEK_CHAT"] = "deepseek-chat";
-  Model2["DEEPSEEK_REASONER"] = "deepseek-reasoner";
-  Model2["GEMINI_2_5_PRO"] = "gemini-2.5-pro";
-  Model2["GEMINI_2_5_FLASH"] = "gemini-2.5-flash";
-  Model2["GEMINI_2_5_FLASH_LITE"] = "gemini-2.5-flash-lite";
-  Model2["GEMINI_2_0_FLASH_EXP"] = "gemini-2.0-flash-exp";
-  Model2["GEMINI_1_5_PRO"] = "gemini-1.5-pro";
-  Model2["GEMINI_1_5_PRO_002"] = "gemini-1.5-pro-002";
-  Model2["GEMINI_1_5_FLASH"] = "gemini-1.5-flash";
-  Model2["GEMINI_1_5_FLASH_002"] = "gemini-1.5-flash-002";
-  Model2["GEMINI_1_5_FLASH_8B"] = "gemini-1.5-flash-8b";
-  Model2["GEMINI_1_5_FLASH_8B_001"] = "gemini-1.5-flash-8b-001";
-  Model2["GEMMA_3_2B"] = "gemma-3-2b";
-  Model2["GEMMA_3_9B"] = "gemma-3-9b";
-  Model2["GEMMA_3_27B"] = "gemma-3-27b";
-  Model2["GEMMA_2_2B"] = "gemma-2-2b";
-  Model2["GEMMA_2_9B"] = "gemma-2-9b";
-  Model2["GEMMA_2_27B"] = "gemma-2-27b";
-  Model2["CODE_GEMMA_2B"] = "codegemma-2b";
-  Model2["CODE_GEMMA_7B"] = "codegemma-7b";
-  Model2["MISTRAL_LARGE_LATEST"] = "mistral-large-latest";
-  Model2["MISTRAL_SMALL_LATEST"] = "mistral-small-latest";
-  Model2["CODESTRAL_LATEST"] = "codestral-latest";
-  Model2["MINISTRAL_8B_LATEST"] = "ministral-8b-latest";
-  Model2["MINISTRAL_3B_LATEST"] = "ministral-3b-latest";
-  return Model2;
-})(Model || {});
-var SUPPORTED_MODELS = [
-  {
-    id: "claude-opus-4-0" /* CLAUDE_OPUS_4_0 */,
-    name: "Claude Opus 4",
-    provider: "anthropic"
-  },
-  {
-    id: "claude-sonnet-4-0" /* CLAUDE_SONNET_4_0 */,
-    name: "Claude Sonnet 4",
-    provider: "anthropic"
-  },
-  {
-    id: "claude-3-7-sonnet-latest" /* CLAUDE_3_7_SONNET_LATEST */,
-    name: "Claude Sonnet 3.7",
-    provider: "anthropic"
-  },
-  {
-    id: "claude-3-5-sonnet-latest" /* CLAUDE_3_5_SONNET_LATEST */,
-    name: "Claude Sonnet 3.5",
-    provider: "anthropic"
-  },
-  {
-    id: "claude-3-5-haiku-latest" /* CLAUDE_3_5_HAIKU_LATEST */,
-    name: "Claude Haiku 3.5",
-    provider: "anthropic"
-  },
-  { id: "gpt-5" /* GPT_5 */, name: "GPT-5", provider: "openai" },
-  { id: "gpt-5-mini" /* GPT_5_MINI */, name: "GPT-5 Mini", provider: "openai" },
-  { id: "gpt-5-nano" /* GPT_5_NANO */, name: "GPT-5 Nano", provider: "openai" },
-  { id: Model.GPT_5_CHAT_LATEST, name: "GPT-5 Chat", provider: "openai" },
-  { id: "gpt-5-pro" /* GPT_5_PRO */, name: "GPT-5 Pro", provider: "openai" },
-  { id: "gpt-5-codex" /* GPT_5_CODEX */, name: "GPT-5 Codex", provider: "openai" },
-  { id: "gpt-4.1" /* GPT_4_1 */, name: "GPT-4.1", provider: "openai" },
-  { id: "gpt-4.1-mini" /* GPT_4_1_MINI */, name: "GPT-4.1 Mini", provider: "openai" },
-  { id: "gpt-4.1-nano" /* GPT_4_1_NANO */, name: "GPT-4.1 Nano", provider: "openai" },
-  { id: "gpt-4o" /* GPT_4O */, name: "GPT-4o", provider: "openai" },
-  { id: "gpt-4o-mini" /* GPT_4O_MINI */, name: "GPT-4o Mini", provider: "openai" },
-  { id: "deepseek-chat" /* DEEPSEEK_CHAT */, name: "DeepSeek Chat", provider: "deepseek" },
-  {
-    id: "deepseek-reasoner" /* DEEPSEEK_REASONER */,
-    name: "DeepSeek Reasoner",
-    provider: "deepseek"
-  },
-  // Google Gemini models (latest first)
-  {
-    id: "gemini-2.5-pro" /* GEMINI_2_5_PRO */,
-    name: "Gemini 2.5 Pro",
-    provider: "google"
-  },
-  {
-    id: "gemini-2.5-flash" /* GEMINI_2_5_FLASH */,
-    name: "Gemini 2.5 Flash",
-    provider: "google"
-  },
-  {
-    id: "gemini-2.0-flash-exp" /* GEMINI_2_0_FLASH_EXP */,
-    name: "Gemini 2.0 Flash Experimental",
-    provider: "google"
-  },
-  {
-    id: "gemini-1.5-pro-002" /* GEMINI_1_5_PRO_002 */,
-    name: "Gemini 1.5 Pro 002",
-    provider: "google"
-  },
-  {
-    id: "gemini-1.5-pro" /* GEMINI_1_5_PRO */,
-    name: "Gemini 1.5 Pro",
-    provider: "google"
-  },
-  {
-    id: "gemini-1.5-flash-002" /* GEMINI_1_5_FLASH_002 */,
-    name: "Gemini 1.5 Flash 002",
-    provider: "google"
-  },
-  {
-    id: "gemini-1.5-flash" /* GEMINI_1_5_FLASH */,
-    name: "Gemini 1.5 Flash",
-    provider: "google"
-  },
-  {
-    id: "meta-llama/llama-3.3-70b-instruct",
-    name: "Llama 3.3 70B (Free)",
-    provider: "meta"
-  },
-  {
-    id: "openai/gpt-oss-120b",
-    name: "GPT-OSS 120B (Free)",
-    provider: "openai"
-  },
-  {
-    id: "x-ai/grok-4-fast",
-    name: "Grok 4 Fast (Free)",
-    provider: "x-ai"
-  },
-  {
-    id: "openai/gpt-5-nano",
-    name: "GPT-5 Nano (Free)",
-    provider: "openai"
-  },
-  {
-    id: "anthropic/claude-sonnet-4.5",
-    name: "Claude Sonnet 4.5 (Free)",
-    provider: "anthropic"
-  },
-  {
-    id: "anthropic/claude-haiku-4.5",
-    name: "Claude Haiku 4.5 (Free)",
-    provider: "anthropic"
-  },
-  {
-    id: "openai/gpt-5-codex",
-    name: "GPT-5 Codex (Free)",
-    provider: "openai"
-  },
-  {
-    id: "openai/gpt-5",
-    name: "GPT-5 (Free)",
-    provider: "openai"
-  },
-  {
-    id: "openai/gpt-5-mini",
-    name: "GPT-5 Mini (Free)",
-    provider: "openai"
-  },
-  {
-    id: "google/gemini-2.5-flash-preview-09-2025",
-    name: "Gemini 2.5 Flash Preview (Free)",
-    provider: "google"
-  },
-  {
-    id: "moonshotai/kimi-k2-0905",
-    name: "Kimi K2 (Free)",
-    provider: "moonshotai"
-  },
-  {
-    id: "google/gemini-2.5-flash",
-    name: "Gemini 2.5 Flash (Free)",
-    provider: "google"
-  },
-  {
-    id: "z-ai/glm-4.6",
-    name: "GLM 4.6 (Free)",
-    provider: "z-ai"
-  },
-  // Mistral models
-  {
-    id: "mistral-large-latest" /* MISTRAL_LARGE_LATEST */,
-    name: "Mistral Large",
-    provider: "mistral"
-  },
-  {
-    id: "mistral-small-latest" /* MISTRAL_SMALL_LATEST */,
-    name: "Mistral Small",
-    provider: "mistral"
-  },
-  {
-    id: "codestral-latest" /* CODESTRAL_LATEST */,
-    name: "Codestral",
-    provider: "mistral"
-  },
-  {
-    id: "ministral-8b-latest" /* MINISTRAL_8B_LATEST */,
-    name: "Ministral 8B",
-    provider: "mistral"
-  },
-  {
-    id: "ministral-3b-latest" /* MINISTRAL_3B_LATEST */,
-    name: "Ministral 3B",
-    provider: "mistral"
-  }
-];
 
 // routes/mcp/chat.ts
 import { TextEncoder as TextEncoder2 } from "util";
@@ -3045,9 +2861,392 @@ chat.post("/", async (c) => {
 });
 var chat_default = chat;
 
-// routes/mcp/oauth.ts
+// routes/mcp/chat-v2.ts
 import { Hono as Hono7 } from "hono";
-var oauth = new Hono7();
+import {
+  convertToModelMessages,
+  streamText as streamText2,
+  stepCountIs,
+  createUIMessageStream,
+  createUIMessageStreamResponse
+} from "ai";
+import zodToJsonSchema2 from "zod-to-json-schema";
+var DEFAULT_TEMPERATURE = 0.7;
+var chatV2 = new Hono7();
+chatV2.post("/", async (c) => {
+  try {
+    const body = await c.req.json();
+    const mcpClientManager2 = c.mcpClientManager;
+    const {
+      messages,
+      apiKey,
+      model,
+      systemPrompt,
+      temperature,
+      selectedServers
+    } = body;
+    if (!Array.isArray(messages) || messages.length === 0) {
+      return c.json({ error: "messages are required" }, 400);
+    }
+    const modelDefinition = model;
+    if (!modelDefinition) {
+      return c.json({ error: "model is not supported" }, 400);
+    }
+    console.log("selectedServers", selectedServers);
+    const mcpTools = await mcpClientManager2.getToolsForAiSdk(selectedServers);
+    if (modelDefinition.id && isMCPJamProvidedModel(modelDefinition.id)) {
+      if (!process.env.CONVEX_HTTP_URL) {
+        return c.json(
+          { error: "Server missing CONVEX_HTTP_URL configuration" },
+          500
+        );
+      }
+      const flattenedTools = mcpTools;
+      const toolDefs = [];
+      for (const [name, tool2] of Object.entries(flattenedTools)) {
+        if (!tool2) continue;
+        let serializedSchema;
+        const schema = tool2.inputSchema;
+        if (schema) {
+          if (typeof schema === "object" && schema !== null && "jsonSchema" in schema) {
+            serializedSchema = schema.jsonSchema;
+          } else {
+            try {
+              serializedSchema = zodToJsonSchema2(schema);
+            } catch {
+              serializedSchema = {
+                type: "object",
+                properties: {},
+                additionalProperties: false
+              };
+            }
+          }
+        }
+        toolDefs.push({
+          name,
+          description: tool2.description,
+          inputSchema: serializedSchema ?? {
+            type: "object",
+            properties: {},
+            additionalProperties: false
+          }
+        });
+      }
+      const authHeader = c.req.header("authorization") || void 0;
+      let messageHistory = convertToModelMessages(messages);
+      let steps = 0;
+      const MAX_STEPS2 = 20;
+      const stream = createUIMessageStream({
+        execute: async ({ writer }) => {
+          const msgId = `asst_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          while (steps < MAX_STEPS2) {
+            const res = await fetch(`${process.env.CONVEX_HTTP_URL}/stream`, {
+              method: "POST",
+              headers: {
+                "content-type": "application/json",
+                ...authHeader ? { authorization: authHeader } : {}
+              },
+              body: JSON.stringify({
+                mode: "step",
+                messages: JSON.stringify(messageHistory),
+                model: String(modelDefinition.id),
+                systemPrompt,
+                temperature: temperature ?? DEFAULT_TEMPERATURE,
+                tools: toolDefs
+              })
+            });
+            if (!res.ok) {
+              const errorText = await res.text().catch(() => "step failed");
+              writer.write({ type: "error", errorText });
+              break;
+            }
+            const json = await res.json();
+            if (!json?.ok || !Array.isArray(json.messages)) {
+              break;
+            }
+            for (const m of json.messages) {
+              if (m?.role === "assistant" && Array.isArray(m.content)) {
+                for (const item of m.content) {
+                  if (item?.type === "text" && typeof item.text === "string") {
+                    writer.write({ type: "text-start", id: msgId });
+                    writer.write({
+                      type: "text-delta",
+                      id: msgId,
+                      delta: item.text
+                    });
+                    writer.write({ type: "text-end", id: msgId });
+                  } else if (item?.type === "tool-call") {
+                    if (item.input == null)
+                      item.input = item.parameters ?? item.args ?? {};
+                    if (!item.toolCallId)
+                      item.toolCallId = `tc_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+                    writer.write({
+                      type: "tool-input-available",
+                      toolCallId: item.toolCallId,
+                      toolName: item.toolName ?? item.name,
+                      input: item.input
+                    });
+                  }
+                }
+              }
+              messageHistory.push(m);
+            }
+            const beforeLen = messageHistory.length;
+            if (hasUnresolvedToolCalls(messageHistory)) {
+              await executeToolCallsFromMessages(messageHistory, {
+                clientManager: mcpClientManager2
+              });
+            }
+            const newMessages = messageHistory.slice(beforeLen);
+            for (const msg of newMessages) {
+              if (msg?.role === "tool" && Array.isArray(msg.content)) {
+                for (const item of msg.content) {
+                  if (item?.type === "tool-result") {
+                    writer.write({
+                      type: "tool-output-available",
+                      toolCallId: item.toolCallId,
+                      output: item.output ?? item.result ?? item.value
+                    });
+                  }
+                }
+              }
+            }
+            steps++;
+            const finishReason = json.finishReason;
+            if (finishReason && finishReason !== "tool-calls") {
+              break;
+            }
+          }
+        }
+      });
+      return createUIMessageStreamResponse({ stream });
+    }
+    const llmModel = createLlmModel(
+      modelDefinition,
+      apiKey ?? "",
+      body.ollamaBaseUrl,
+      body.litellmBaseUrl
+    );
+    const result = streamText2({
+      model: llmModel,
+      messages: convertToModelMessages(messages),
+      temperature: temperature ?? DEFAULT_TEMPERATURE,
+      system: systemPrompt,
+      tools: mcpTools,
+      stopWhen: stepCountIs(20)
+    });
+    return result.toUIMessageStreamResponse();
+  } catch (error) {
+    console.error("[mcp/chat-v2] failed to process chat request", error);
+    return c.json({ error: "Unexpected error" }, 500);
+  }
+});
+var chat_v2_default = chatV2;
+
+// routes/mcp/oauth.ts
+import { Hono as Hono8 } from "hono";
+var oauth = new Hono8();
+oauth.post("/debug/proxy", async (c) => {
+  try {
+    const {
+      url,
+      method = "GET",
+      body,
+      headers: customHeaders
+    } = await c.req.json();
+    if (!url) {
+      return c.json({ error: "Missing url parameter" }, 400);
+    }
+    let targetUrl;
+    try {
+      targetUrl = new URL(url);
+      if (targetUrl.protocol !== "https:" && targetUrl.protocol !== "http:") {
+        return c.json({ error: "Invalid protocol" }, 400);
+      }
+    } catch (error) {
+      return c.json({ error: "Invalid URL format" }, 400);
+    }
+    const requestHeaders = {
+      "User-Agent": "MCP-Inspector/1.0",
+      ...customHeaders
+    };
+    console.log("[OAuth Debug Proxy]");
+    console.log("  URL:", url);
+    console.log("  Method:", method);
+    console.log("  Headers:", requestHeaders);
+    if (body) {
+      console.log("  Body:", JSON.stringify(body, null, 2));
+    }
+    const contentType = customHeaders?.["Content-Type"] || customHeaders?.["content-type"];
+    const isFormUrlEncoded = contentType?.includes(
+      "application/x-www-form-urlencoded"
+    );
+    if (method === "POST" && body && !contentType) {
+      requestHeaders["Content-Type"] = "application/json";
+    }
+    const fetchOptions = {
+      method,
+      headers: requestHeaders
+    };
+    if (method === "POST" && body) {
+      if (isFormUrlEncoded && typeof body === "object") {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(body)) {
+          params.append(key, String(value));
+        }
+        fetchOptions.body = params.toString();
+      } else {
+        fetchOptions.body = JSON.stringify(body);
+      }
+    }
+    const response = await fetch(targetUrl.toString(), fetchOptions);
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    let responseBody = null;
+    const contentTypeHeader = headers["content-type"] || "";
+    if (contentTypeHeader.includes("text/event-stream")) {
+      try {
+        const text = await response.text();
+        const events = [];
+        const lines = text.split("\n");
+        let currentEvent = {};
+        for (const line of lines) {
+          if (line.startsWith("event:")) {
+            currentEvent.event = line.substring(6).trim();
+          } else if (line.startsWith("data:")) {
+            const data = line.substring(5).trim();
+            try {
+              currentEvent.data = JSON.parse(data);
+            } catch {
+              currentEvent.data = data;
+            }
+          } else if (line.startsWith("id:")) {
+            currentEvent.id = line.substring(3).trim();
+          } else if (line === "") {
+            if (Object.keys(currentEvent).length > 0) {
+              events.push(currentEvent);
+              currentEvent = {};
+            }
+          }
+        }
+        responseBody = events.length > 0 ? {
+          events,
+          // If there's a "message" event with MCP response, extract it
+          mcpResponse: events.find((e) => e.event === "message" || !e.event)?.data || null
+        } : { raw: text };
+      } catch (error) {
+        console.error("Failed to parse SSE response:", error);
+        responseBody = { error: "Failed to parse SSE stream" };
+      }
+    } else {
+      try {
+        responseBody = await response.json();
+      } catch {
+        try {
+          responseBody = await response.text();
+        } catch {
+          responseBody = null;
+        }
+      }
+    }
+    console.log("  Response:", response.status, response.statusText);
+    return c.json({
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+      body: responseBody
+    });
+  } catch (error) {
+    console.error("[OAuth Debug Proxy] Error:", error);
+    return c.json(
+      {
+        error: error instanceof Error ? error.message : "Unknown error occurred"
+      },
+      500
+    );
+  }
+});
+oauth.post("/proxy", async (c) => {
+  try {
+    const {
+      url,
+      method = "GET",
+      body,
+      headers: customHeaders
+    } = await c.req.json();
+    if (!url) {
+      return c.json({ error: "Missing url parameter" }, 400);
+    }
+    let targetUrl;
+    try {
+      targetUrl = new URL(url);
+      if (targetUrl.protocol !== "https:" && targetUrl.protocol !== "http:") {
+        return c.json({ error: "Invalid protocol" }, 400);
+      }
+    } catch (error) {
+      return c.json({ error: "Invalid URL format" }, 400);
+    }
+    const requestHeaders = {
+      "User-Agent": "MCP-Inspector/1.0",
+      ...customHeaders
+    };
+    const contentType = customHeaders?.["Content-Type"] || customHeaders?.["content-type"];
+    const isFormUrlEncoded = contentType?.includes(
+      "application/x-www-form-urlencoded"
+    );
+    if (method === "POST" && body && !contentType) {
+      requestHeaders["Content-Type"] = "application/json";
+    }
+    const fetchOptions = {
+      method,
+      headers: requestHeaders
+    };
+    if (method === "POST" && body) {
+      if (isFormUrlEncoded && typeof body === "object") {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(body)) {
+          params.append(key, String(value));
+        }
+        fetchOptions.body = params.toString();
+      } else if (typeof body === "string") {
+        fetchOptions.body = body;
+      } else {
+        fetchOptions.body = JSON.stringify(body);
+      }
+    }
+    const response = await fetch(targetUrl.toString(), fetchOptions);
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    let responseBody = null;
+    try {
+      responseBody = await response.json();
+    } catch {
+      try {
+        responseBody = await response.text();
+      } catch {
+        responseBody = null;
+      }
+    }
+    return c.json({
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+      body: responseBody
+    });
+  } catch (error) {
+    console.error("OAuth proxy error:", error);
+    return c.json(
+      {
+        error: error instanceof Error ? error.message : "Unknown error occurred"
+      },
+      500
+    );
+  }
+});
 oauth.get("/metadata", async (c) => {
   try {
     const url = c.req.query("url");
@@ -3057,8 +3256,8 @@ oauth.get("/metadata", async (c) => {
     let metadataUrl;
     try {
       metadataUrl = new URL(url);
-      if (metadataUrl.protocol !== "https:") {
-        return c.json({ error: "Only HTTPS URLs are allowed" }, 400);
+      if (metadataUrl.protocol !== "https:" && metadataUrl.protocol !== "http:") {
+        return c.json({ error: "Invalid protocol" }, 400);
       }
     } catch (error) {
       return c.json({ error: "Invalid URL format" }, 400);
@@ -3093,8 +3292,8 @@ oauth.get("/metadata", async (c) => {
 var oauth_default = oauth;
 
 // routes/mcp/export.ts
-import { Hono as Hono8 } from "hono";
-var exporter = new Hono8();
+import { Hono as Hono9 } from "hono";
+var exporter = new Hono9();
 exporter.post("/server", async (c) => {
   try {
     const { serverId } = await c.req.json();
@@ -3150,20 +3349,20 @@ exporter.post("/server", async (c) => {
 var export_default = exporter;
 
 // routes/mcp/interceptor.ts
-import { Hono as Hono9 } from "hono";
-var interceptor = new Hono9();
+import { Hono as Hono10 } from "hono";
+var interceptor = new Hono10();
 var interceptor_default = interceptor;
 
 // routes/mcp/evals.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 import { z as z3 } from "zod";
 
 // ../evals-cli/src/evals/runner.ts
 import { MCPClient } from "@mastra/mcp";
-import { streamText as streamText2 } from "ai";
+import { streamText as streamText3 } from "ai";
 
 // ../node_modules/convex/dist/esm/index.js
-var version = "1.28.0";
+var version = "1.27.3";
 
 // ../node_modules/convex/dist/esm/values/base64.js
 var lookup = [];
@@ -3794,7 +3993,7 @@ function createApi(pathParts = []) {
 }
 var anyApi = createApi();
 
-// ../node_modules/convex/dist/esm/vendor/long.js
+// ../node_modules/convex/dist/esm/browser/long.js
 var __defProp4 = Object.defineProperty;
 var __defNormalProp3 = (obj, key, value) => key in obj ? __defProp4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField3 = (obj, key, value) => __defNormalProp3(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -3871,7 +4070,7 @@ var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
 var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
 var MAX_UNSIGNED_VALUE = new Long(4294967295 | 0, 4294967295 | 0);
 
-// ../node_modules/convex/dist/esm/vendor/jwt-decode/index.js
+// ../node_modules/jwt-decode/build/esm/index.js
 var InvalidTokenError = class extends Error {
 };
 InvalidTokenError.prototype.name = "InvalidTokenError";
@@ -8689,7 +8888,7 @@ import { z as z2 } from "zod";
 
 // ../shared/tools.ts
 import { z } from "zod";
-import { zodToJsonSchema as zodToJsonSchema2 } from "zod-to-json-schema";
+import { zodToJsonSchema as zodToJsonSchema3 } from "zod-to-json-schema";
 import { tool } from "ai";
 var fallbackInputSchema = z.object({}).passthrough();
 var UNREPRESENTABLE_JSON_SCHEMA_MESSAGES = [
@@ -8724,7 +8923,7 @@ function canConvertToJSONSchema(schema) {
     }
   }
   try {
-    zodToJsonSchema2(schema);
+    zodToJsonSchema3(schema);
     return true;
   } catch (error) {
     if (isUnrepresentableSchemaError(error)) {
@@ -9237,7 +9436,7 @@ var runIteration = async ({
     let assistantStreaming = false;
     let streamResult;
     try {
-      streamResult = await streamText2({
+      streamResult = await streamText3({
         model: createLlmModel2(provider, model, llms),
         system,
         temperature,
@@ -9695,7 +9894,7 @@ async function collectToolsForServers(clientManager, serverIds) {
   );
   return perServerTools.flat();
 }
-var evals = new Hono10();
+var evals = new Hono11();
 var RunEvalsRequestSchema = z3.object({
   tests: z3.array(
     z3.object({
@@ -9835,11 +10034,11 @@ evals.post("/generate-tests", async (c) => {
 var evals_default = evals;
 
 // routes/mcp/http-adapters.ts
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono12 } from "hono";
 
 // services/mcp-http-bridge.ts
 import { z as z4 } from "zod";
-import { zodToJsonSchema as zodToJsonSchema3 } from "zod-to-json-schema";
+import { zodToJsonSchema as zodToJsonSchema4 } from "zod-to-json-schema";
 function buildInitializeResult(serverId, mode) {
   if (mode === "adapter") {
     return {
@@ -9871,7 +10070,7 @@ function toJsonSchemaMaybe(schema) {
   try {
     if (schema && typeof schema === "object") {
       if (schema instanceof z4.ZodType || "_def" in schema && "parse" in schema) {
-        return zodToJsonSchema3(schema);
+        return zodToJsonSchema4(schema);
       }
     }
   } catch {
@@ -10042,7 +10241,7 @@ async function handleJsonRpc(serverId, body, clientManager, mode) {
 var sessions = /* @__PURE__ */ new Map();
 var latestSessionByServer = /* @__PURE__ */ new Map();
 function createHttpHandler(mode, routePrefix) {
-  const router = new Hono11();
+  const router = new Hono12();
   router.options(
     "/:serverId",
     (c) => c.body(null, 204, {
@@ -10261,8 +10460,115 @@ function createHttpHandler(mode, routePrefix) {
 var adapterHttp = createHttpHandler("adapter", "adapter-http");
 var managerHttp = createHttpHandler("manager", "manager-http");
 
+// routes/mcp/elicitation.ts
+import { Hono as Hono13 } from "hono";
+var elicitation = new Hono13();
+var elicitationSubscribers = /* @__PURE__ */ new Set();
+function broadcastElicitation(event) {
+  for (const sub of Array.from(elicitationSubscribers)) {
+    try {
+      sub.send(event);
+    } catch {
+      try {
+        sub.close();
+      } catch {
+      }
+      elicitationSubscribers.delete(sub);
+    }
+  }
+}
+var isCallbackRegistered = false;
+elicitation.use("*", async (c, next) => {
+  if (!isCallbackRegistered) {
+    const manager = c.mcpClientManager;
+    manager.setElicitationCallback(({ requestId, message, schema }) => {
+      return new Promise((resolve2, reject) => {
+        try {
+          manager.getPendingElicitations().set(requestId, { resolve: resolve2, reject });
+        } catch {
+        }
+        broadcastElicitation({
+          type: "elicitation_request",
+          requestId,
+          message,
+          schema,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      });
+    });
+    isCallbackRegistered = true;
+  }
+  await next();
+});
+elicitation.get("/stream", async (c) => {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    start(controller) {
+      const send = (event) => {
+        const payload = `data: ${JSON.stringify(event)}
+
+`;
+        controller.enqueue(encoder.encode(payload));
+      };
+      const keepAlive = setInterval(() => {
+        try {
+          controller.enqueue(encoder.encode(`: keep-alive
+
+`));
+        } catch {
+        }
+      }, 25e3);
+      const close = () => {
+        clearInterval(keepAlive);
+        try {
+          controller.close();
+        } catch {
+        }
+      };
+      controller.enqueue(encoder.encode(`retry: 1500
+
+`));
+      const subscriber = { send, close };
+      elicitationSubscribers.add(subscriber);
+      c.req.raw.signal?.addEventListener?.("abort", () => {
+        elicitationSubscribers.delete(subscriber);
+        close();
+      });
+    }
+  });
+  return new Response(stream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+});
+elicitation.post("/respond", async (c) => {
+  try {
+    const body = await c.req.json();
+    const { requestId, action, content } = body;
+    if (!requestId || !action) {
+      return c.json({ error: "Missing requestId or action" }, 400);
+    }
+    const response = action === "accept" ? { action: "accept", content: content ?? {} } : { action };
+    const ok = c.mcpClientManager.respondToElicitation(requestId, response);
+    if (!ok) {
+      return c.json({ error: "Unknown or expired requestId" }, 404);
+    }
+    broadcastElicitation({ type: "elicitation_complete", requestId });
+    return c.json({ ok: true });
+  } catch (e) {
+    return c.json({ error: e?.message || "Failed to respond" }, 400);
+  }
+});
+var elicitation_default = elicitation;
+
 // routes/mcp/index.ts
-var mcp = new Hono12();
+var mcp = new Hono14();
 mcp.get("/health", (c) => {
   return c.json({
     service: "MCP API",
@@ -10271,6 +10577,8 @@ mcp.get("/health", (c) => {
   });
 });
 mcp.route("/chat", chat_default);
+mcp.route("/chat-v2", chat_v2_default);
+mcp.route("/elicitation", elicitation_default);
 mcp.route("/connect", connect_default);
 mcp.route("/servers", servers_default);
 mcp.route("/tools", tools_default);
@@ -10486,7 +10794,7 @@ try {
   fixPath();
 } catch {
 }
-var app = new Hono13().onError((err, c) => {
+var app = new Hono15().onError((err, c) => {
   console.error("Unhandled error:", err);
   Sentry2.captureException(err);
   if (err instanceof HTTPException) {