@mcpjam/inspector 0.9.29 → 0.9.30

package/dist/server/index.js

@@ -1,7 +1,7 @@
 // index.ts
 import { serve } from "@hono/node-server";
 import fixPath from "fix-path";
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono13 } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
 import { serveStatic } from "@hono/node-server/serve-static";
@@ -9,7 +9,7 @@ import { readFileSync } from "fs";
 import { join } from "path";
 
 // routes/mcp/index.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono12 } from "hono";
 
 // routes/mcp/connect.ts
 import { Hono } from "hono";
@@ -3516,10 +3516,6 @@ var chat_default = chat;
 
 // routes/mcp/tests.ts
 import { Hono as Hono7 } from "hono";
-import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
-import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
-import { createOllama as createOllama2 } from "ollama-ai-provider";
-import { Agent as Agent2 } from "@mastra/core/agent";
 
 // utils/mcp-utils.ts
 import { MCPClient } from "@mastra/mcp";
@@ -3537,10 +3533,7 @@ function validateServerConfig(serverConfig) {
   if (config.url) {
     try {
       if (typeof config.url === "string") {
-        const parsed = new URL(config.url);
-        parsed.search = "";
-        parsed.hash = "";
-        config.url = parsed;
+        config.url = new URL(config.url);
       } else if (typeof config.url === "object" && !config.url.href) {
         return {
           success: false,
@@ -3697,39 +3690,72 @@ function normalizeServerConfigName(serverName) {
 
 // routes/mcp/tests.ts
 var tests = new Hono7();
+function normalizeToolName(toolName, serverIds) {
+  for (const id of serverIds) {
+    const prefix = `${id}_`;
+    if (toolName.startsWith(prefix)) {
+      return toolName.slice(prefix.length);
+    }
+  }
+  return toolName;
+}
+function extractToolSchema(tool) {
+  if (!tool?.inputSchema) return {};
+  const jsonSchema2 = tool.inputSchema.toJSON?.();
+  if (jsonSchema2 && typeof jsonSchema2 === "object") {
+    return jsonSchema2;
+  }
+  const zodDef = tool.inputSchema._def;
+  if (zodDef?.typeName === "ZodObject") {
+    const baseSchema = {
+      type: "object",
+      additionalProperties: false,
+      properties: {},
+      required: []
+    };
+    try {
+      if (zodDef.shape && typeof zodDef.shape === "function") {
+        const shape = zodDef.shape();
+        const properties = {};
+        const required = [];
+        for (const [key, value] of Object.entries(shape)) {
+          properties[key] = { type: "string" };
+          if (value?._def?.typeName !== "ZodOptional") {
+            required.push(key);
+          }
+        }
+        return { ...baseSchema, properties, required };
+      }
+    } catch {
+    }
+    return baseSchema;
+  }
+  return {};
+}
+function resolveBackendUrl(overrideUrl) {
+  return "https://industrious-stingray-146.convex.site";
+  if (overrideUrl) return overrideUrl.replace(/\/$/, "");
+  const explicit = process.env.CONVEX_HTTP_URL;
+  if (explicit) return explicit.replace(/\/$/, "");
+  const convexUrl = process.env.VITE_CONVEX_URL || process.env.CONVEX_URL;
+  if (convexUrl) {
+    try {
+      const u = new URL(convexUrl);
+      const host = u.host.replace(".convex.cloud", ".convex.site");
+      return `${u.protocol}//${host}`;
+    } catch {
+    }
+  }
+  return "http://localhost:3210";
+}
 var tests_default = tests;
 tests.post("/run-all", async (c) => {
   const encoder = new TextEncoder();
   try {
-    let createModel2 = function(model) {
-      switch (model.provider) {
-        case "anthropic":
-          return createAnthropic2({
-            apiKey: providerApiKeys?.anthropic || process.env.ANTHROPIC_API_KEY || ""
-          })(model.id);
-        case "openai":
-          return createOpenAI2({
-            apiKey: providerApiKeys?.openai || process.env.OPENAI_API_KEY || ""
-          })(model.id);
-        case "deepseek":
-          return createOpenAI2({
-            apiKey: providerApiKeys?.deepseek || process.env.DEEPSEEK_API_KEY || "",
-            baseURL: "https://api.deepseek.com/v1"
-          })(model.id);
-        case "ollama":
-          return createOllama2({
-            baseURL: ollamaBaseUrl || process.env.OLLAMA_BASE_URL || "http://localhost:11434/api"
-          })(model.id, { simulateStreaming: true });
-        default:
-          throw new Error(`Unsupported provider: ${model.provider}`);
-      }
-    };
-    var createModel = createModel2;
     const body = await c.req.json();
     const testsInput = body?.tests || [];
+    const overrideBackendHttpUrl = body?.backendHttpUrl;
     const allServers = body?.allServers || {};
-    const providerApiKeys = body?.providerApiKeys || {};
-    const ollamaBaseUrl = body?.ollamaBaseUrl;
     const maxConcurrency = Math.max(
       1,
       Math.min(8, body?.concurrency ?? 5)
@@ -3787,55 +3813,149 @@ tests.post("/run-all", async (c) => {
                 throw new Error("No valid MCP server configs for test");
               }
               client = createMCPClientWithMultipleConnections(finalServers);
-              const model = createModel2(test.model);
-              const agent = new Agent2({
-                name: `TestAgent-${test.id}`,
-                instructions: "You are a helpful assistant with access to MCP tools",
-                model
-              });
-              const toolsets = await client.getToolsets();
-              const stream = await agent.streamVNext(
-                [{ role: "user", content: test.prompt || "" }],
-                {
-                  maxSteps: 10,
-                  toolsets
-                }
+              const tools2 = await client.getTools();
+              const toolsSchemas = Object.entries(tools2).map(
+                ([name17, tool]) => ({
+                  toolName: name17,
+                  inputSchema: extractToolSchema(tool)
+                })
               );
-              for await (const chunk of stream.fullStream) {
-                if (chunk.type === "tool-call" && chunk.payload) {
-                  const toolName = chunk.payload.toolName;
-                  if (toolName) {
-                    calledTools.add(toolName);
-                  }
-                }
-                if (chunk.type === "finish") {
-                  step += 1;
+              const runId = `${Date.now()}-${test.id}`;
+              const backendUrl = resolveBackendUrl(overrideBackendHttpUrl);
+              controller.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify({ type: "debug", testId: test.id, backendUrl })}
+
+`
+                )
+              );
+              const startRes = await fetch(`${backendUrl}/evals/agent/start`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                  runId,
+                  model: test.model,
+                  toolsSchemas,
+                  messages: [
+                    {
+                      role: "system",
+                      content: "You are a helpful assistant with access to MCP tools."
+                    },
+                    { role: "user", content: test.prompt || "" }
+                  ]
+                })
+              });
+              if (!startRes.ok) {
+                const errText = await startRes.text().catch(() => "");
+                controller.enqueue(
+                  encoder.encode(
+                    `data: ${JSON.stringify({ type: "result", testId: test.id, passed: false, error: `Backend start failed: ${startRes.status} ${errText}` })}
+
+`
+                  )
+                );
+                throw new Error(
+                  `Backend start failed: ${startRes.status} ${errText}`
+                );
+              }
+              const startJson = await startRes.json();
+              if (!startJson.ok)
+                throw new Error(startJson.error || "start failed");
+              let state = startJson;
+              const serverIds = Object.keys(finalServers);
+              while (state.kind === "tool_call") {
+                const name17 = state.toolName;
+                const args = state.args || {};
+                const tool = tools2[name17];
+                try {
+                  const result = await tool?.execute({ context: args });
+                  calledTools.add(name17);
                   controller.enqueue(
                     encoder.encode(
                       `data: ${JSON.stringify({
                         type: "trace_step",
                         testId: test.id,
-                        step,
-                        text: "Test completed",
-                        toolCalls: Array.from(calledTools),
-                        toolResults: []
+                        step: ++step,
+                        text: "Executed tool",
+                        toolCalls: [normalizeToolName(name17, serverIds)],
+                        toolResults: [result]
                       })}
 
 `
                     )
                   );
+                  const stepRes = await fetch(
+                    `${backendUrl}/evals/agent/step`,
+                    {
+                      method: "POST",
+                      headers: { "content-type": "application/json" },
+                      body: JSON.stringify({
+                        runId,
+                        model: test.model,
+                        toolsSchemas,
+                        messages: state.steps?.[state.steps.length - 1]?.messages || [
+                          {
+                            role: "system",
+                            content: "You are a helpful assistant with access to MCP tools."
+                          },
+                          { role: "user", content: test.prompt || "" }
+                        ],
+                        toolResultMessage: {
+                          role: "tool",
+                          content: [
+                            {
+                              type: "tool-result",
+                              toolCallId: state.toolCallId,
+                              toolName: name17,
+                              output: result
+                            }
+                          ]
+                        }
+                      })
+                    }
+                  );
+                  const stepJson = await stepRes.json();
+                  if (!stepJson.ok) {
+                    controller.enqueue(
+                      encoder.encode(
+                        `data: ${JSON.stringify({
+                          type: "result",
+                          testId: test.id,
+                          passed: false,
+                          error: stepJson.error || "step failed"
+                        })}
+
+`
+                      )
+                    );
+                    throw new Error(stepJson.error || "step failed");
+                  }
+                  state = stepJson;
+                } catch (err) {
+                  throw new Error(
+                    `Tool '${name17}' failed: ${err instanceof Error ? err.message : String(err)}`
+                  );
                 }
               }
-              const called = Array.from(calledTools);
+              const called = Array.from(calledTools).map(
+                (t) => normalizeToolName(t, serverIds)
+              );
               const missing = Array.from(expectedSet).filter(
-                (t) => !calledTools.has(t)
+                (t) => !called.includes(t)
               );
               const unexpected = called.filter((t) => !expectedSet.has(t));
               const passed = missing.length === 0 && unexpected.length === 0;
               if (!passed) failed = true;
               controller.enqueue(
                 encoder.encode(
-                  `data: ${JSON.stringify({ type: "result", testId: test.id, passed, calledTools: called, missingTools: missing, unexpectedTools: unexpected })}
+                  `data: ${JSON.stringify({
+                    type: "result",
+                    testId: test.id,
+                    passed,
+                    calledTools: called,
+                    missingTools: missing,
+                    unexpectedTools: unexpected
+                  })}
 
 `
                 )
@@ -3981,8 +4101,1187 @@ exporter.post("/server", async (c) => {
 });
 var export_default = exporter;
 
+// routes/mcp/interceptor.ts
+import { Hono as Hono10 } from "hono";
+
+// services/interceptor-store.ts
+import { randomUUID } from "crypto";
+var InterceptorStore = class {
+  interceptors = /* @__PURE__ */ new Map();
+  sessionIndex = /* @__PURE__ */ new Map();
+  byServer = /* @__PURE__ */ new Map();
+  create(targetUrl, injectHeaders, serverId) {
+    const id = randomUUID().replace(/-/g, "");
+    const entry = {
+      id,
+      targetUrl,
+      createdAt: Date.now(),
+      logs: [],
+      subscribers: /* @__PURE__ */ new Set(),
+      injectHeaders,
+      sessionEndpoints: /* @__PURE__ */ new Map(),
+      serverId
+    };
+    this.interceptors.set(id, entry);
+    if (serverId) {
+      if (!this.byServer.has(serverId)) this.byServer.set(serverId, /* @__PURE__ */ new Set());
+      this.byServer.get(serverId).add(id);
+    }
+    return entry;
+  }
+  get(id) {
+    return this.interceptors.get(id);
+  }
+  info(id) {
+    const e = this.interceptors.get(id);
+    if (!e) return void 0;
+    return {
+      id: e.id,
+      targetUrl: e.targetUrl,
+      createdAt: e.createdAt,
+      logCount: e.logs.length,
+      hasInjectedAuth: !!e.injectHeaders?.authorization
+    };
+  }
+  clearLogs(id) {
+    const e = this.interceptors.get(id);
+    if (!e) return false;
+    e.logs = [];
+    this.broadcast(e, { type: "cleared" });
+    return true;
+  }
+  appendLog(id, log) {
+    const e = this.interceptors.get(id);
+    if (!e) return false;
+    e.logs.push(log);
+    this.broadcast(e, { type: "log", log });
+    return true;
+  }
+  listLogs(id) {
+    const e = this.interceptors.get(id);
+    return e?.logs ?? [];
+  }
+  subscribe(id, subscriber) {
+    const e = this.interceptors.get(id);
+    if (!e) return false;
+    e.subscribers.add(subscriber);
+    return () => {
+      e.subscribers.delete(subscriber);
+    };
+  }
+  setSessionEndpoint(id, sessionId, url) {
+    const e = this.interceptors.get(id);
+    if (!e) return false;
+    e.sessionEndpoints.set(sessionId, url);
+    this.sessionIndex.set(sessionId, { interceptorId: id, url });
+    return true;
+  }
+  getSessionEndpoint(id, sessionId) {
+    const e = this.interceptors.get(id);
+    return e?.sessionEndpoints.get(sessionId);
+  }
+  getSessionMapping(sessionId) {
+    return this.sessionIndex.get(sessionId);
+  }
+  destroy(id) {
+    const e = this.interceptors.get(id);
+    if (!e) return false;
+    for (const sub of Array.from(e.subscribers)) {
+      try {
+        sub.send({ type: "closed" });
+      } catch {
+      }
+      try {
+        sub.close();
+      } catch {
+      }
+    }
+    e.subscribers.clear();
+    for (const sid of Array.from(e.sessionEndpoints.keys())) {
+      this.sessionIndex.delete(sid);
+    }
+    this.interceptors.delete(id);
+    return true;
+  }
+  destroyByServer(serverId) {
+    const set = this.byServer.get(serverId);
+    if (!set || set.size === 0) return 0;
+    let count = 0;
+    for (const id of Array.from(set)) {
+      if (this.destroy(id)) count++;
+    }
+    this.byServer.delete(serverId);
+    return count;
+  }
+  broadcast(e, payload) {
+    for (const sub of Array.from(e.subscribers)) {
+      try {
+        sub.send(payload);
+      } catch {
+        try {
+          sub.close();
+        } catch {
+        }
+        e.subscribers.delete(sub);
+      }
+    }
+  }
+};
+var interceptorStore = new InterceptorStore();
+
+// routes/mcp/interceptor.ts
+var interceptor = new Hono10();
+function withCORS(res) {
+  const headers = new Headers(res.headers);
+  headers.set("Access-Control-Allow-Origin", "*");
+  headers.set("Access-Control-Allow-Methods", "GET,POST,HEAD,OPTIONS");
+  headers.set(
+    "Access-Control-Allow-Headers",
+    "Authorization, Content-Type, Accept, Accept-Language"
+  );
+  headers.set("Access-Control-Expose-Headers", "*");
+  headers.set("Vary", "Origin, Access-Control-Request-Headers");
+  headers.delete("content-length");
+  headers.delete("Content-Length");
+  headers.delete("transfer-encoding");
+  headers.delete("Transfer-Encoding");
+  return new Response(res.body, {
+    status: res.status,
+    statusText: res.statusText,
+    headers
+  });
+}
+function maskHeaders(orig) {
+  const out = {};
+  orig.forEach((value, key) => {
+    if (key.toLowerCase() === "authorization") {
+      out[key] = value.startsWith("Bearer ") ? "Bearer ***" : "***";
+    } else {
+      out[key] = value;
+    }
+  });
+  return out;
+}
+interceptor.post("/create", async (c) => {
+  try {
+    const body = await c.req.json();
+    const targetUrl = body?.targetUrl;
+    const serverId = body?.serverId || body?.managerServerId;
+    const urlObj = new URL(c.req.url);
+    let finalTarget = targetUrl;
+    let injectHeaders;
+    if (serverId) {
+      const connected = c.mcpJamClientManager.getConnectedServers();
+      const serverMeta = connected[serverId];
+      const cfg = serverMeta?.config;
+      if (!cfg || serverMeta?.status !== "connected") {
+        return c.json(
+          { success: false, error: `Server '${serverId}' is not connected` },
+          400
+        );
+      }
+      if (!finalTarget) {
+        if (cfg.url) {
+          finalTarget = typeof cfg.url === "string" ? cfg.url : cfg.url.toString();
+        } else {
+          const origin = new URL(c.req.url).origin;
+          finalTarget = `${origin}/api/mcp/adapter-http/${encodeURIComponent(serverId)}`;
+        }
+      }
+      const hdrs = {};
+      const fromReqInit = cfg.requestInit?.headers;
+      if (fromReqInit) {
+        for (const [k, v] of Object.entries(fromReqInit)) {
+          if (typeof v === "string") hdrs[k.toLowerCase()] = v;
+        }
+      }
+      const token = cfg?.oauth?.access_token || cfg?.oauth?.accessToken;
+      if (token && !hdrs["authorization"]) {
+        hdrs["authorization"] = `Bearer ${token}`;
+        hdrs["Authorization"] = `Bearer ${token}`;
+      }
+      injectHeaders = hdrs;
+    }
+    if (!finalTarget) {
+      return c.json(
+        { success: false, error: "targetUrl or serverId is required" },
+        400
+      );
+    }
+    try {
+      const u = new URL(finalTarget);
+      if (!["http:", "https:"].includes(u.protocol)) {
+        return c.json(
+          {
+            success: false,
+            error: "Only HTTP/HTTPS MCP servers are supported"
+          },
+          400
+        );
+      }
+    } catch {
+      return c.json({ success: false, error: "Invalid URL" }, 400);
+    }
+    const entry = interceptorStore.create(finalTarget, injectHeaders, serverId);
+    const localOrigin = urlObj.origin;
+    const publicOrigin = null;
+    const proxyPath = `/api/mcp/interceptor/${entry.id}/proxy`;
+    const localProxyUrl = `${localOrigin}${proxyPath}`;
+    const publicProxyUrl = publicOrigin ? `${publicOrigin}${proxyPath}` : null;
+    const proxyUrl = publicProxyUrl || localProxyUrl;
+    return c.json({
+      success: true,
+      id: entry.id,
+      targetUrl: entry.targetUrl,
+      proxyUrl,
+      localProxyUrl,
+      publicProxyUrl
+    });
+  } catch (err) {
+    return c.json(
+      { success: false, error: err?.message || "Invalid JSON" },
+      400
+    );
+  }
+});
+interceptor.get("/:id", (c) => {
+  const id = c.req.param("id");
+  const info = interceptorStore.info(id);
+  if (!info) return c.json({ success: false, error: "not found" }, 404);
+  const urlObj = new URL(c.req.url);
+  const publicOrigin = null;
+  const proxyPath = `/api/mcp/interceptor/${id}/proxy`;
+  const localProxyUrl = `${urlObj.origin}${proxyPath}`;
+  const publicProxyUrl = publicOrigin ? `${publicOrigin}${proxyPath}` : null;
+  const proxyUrl = publicProxyUrl || localProxyUrl;
+  return c.json({
+    success: true,
+    ...info,
+    proxyUrl,
+    localProxyUrl,
+    publicProxyUrl
+  });
+});
+interceptor.post("/:id/clear", (c) => {
+  const id = c.req.param("id");
+  const ok = interceptorStore.clearLogs(id);
+  if (!ok) return c.json({ success: false, error: "not found" }, 404);
+  return c.json({ success: true });
+});
+interceptor.delete("/:id", (c) => {
+  const id = c.req.param("id");
+  const ok = interceptorStore.destroy(id);
+  if (!ok) return c.json({ success: false, error: "not found" }, 404);
+  return c.json({ success: true });
+});
+interceptor.delete("/by-server/:serverId", (c) => {
+  const serverId = c.req.param("serverId");
+  const count = interceptorStore.destroyByServer(serverId);
+  return c.json({ success: true, count });
+});
+interceptor.get("/:id/stream", (c) => {
+  const id = c.req.param("id");
+  const entry = interceptorStore.get(id);
+  if (!entry) return c.json({ success: false, error: "not found" }, 404);
+  const encoder = new TextEncoder();
+  let unsubscribeFn;
+  const stream = new ReadableStream({
+    start(controller) {
+      for (const log of entry.logs) {
+        controller.enqueue(
+          encoder.encode(`data: ${JSON.stringify({ type: "log", log })}
+
+`)
+        );
+      }
+      const subscriber = {
+        send: (event) => {
+          controller.enqueue(
+            encoder.encode(`data: ${JSON.stringify(event)}
+
+`)
+          );
+        },
+        close: () => controller.close()
+      };
+      const unsubscribe = interceptorStore.subscribe(id, subscriber);
+      unsubscribeFn = unsubscribe;
+    },
+    cancel() {
+      try {
+        unsubscribeFn && unsubscribeFn();
+      } catch {
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET,POST,HEAD,OPTIONS",
+      "Access-Control-Allow-Headers": "*, Authorization, Content-Type, Accept, Accept-Language",
+      "X-Accel-Buffering": "no"
+    }
+  });
+});
+interceptor.options("/:id/proxy", (c) => {
+  return c.body(null, 204, {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET,POST,HEAD,OPTIONS",
+    "Access-Control-Allow-Headers": "Authorization, Content-Type, Accept, Accept-Language",
+    "Access-Control-Max-Age": "86400",
+    Vary: "Origin, Access-Control-Request-Headers"
+  });
+});
+interceptor.options("/:id/proxy/*", (c) => {
+  return c.body(null, 204, {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET,POST,HEAD,OPTIONS",
+    "Access-Control-Allow-Headers": "Authorization, Content-Type, Accept, Accept-Language",
+    "Access-Control-Max-Age": "86400",
+    Vary: "Origin, Access-Control-Request-Headers"
+  });
+});
+async function handleProxy(c) {
+  const id = c.req.param("id");
+  const entry = interceptorStore.get(id);
+  if (!entry) return c.json({ success: false, error: "not found" }, 404);
+  const req = c.req.raw;
+  const requestId = `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  let requestBody;
+  try {
+    const clone = req.clone();
+    requestBody = await clone.text();
+  } catch {
+    requestBody = void 0;
+  }
+  interceptorStore.appendLog(id, {
+    id: requestId,
+    timestamp: Date.now(),
+    direction: "request",
+    method: req.method,
+    url: entry.targetUrl,
+    headers: maskHeaders(req.headers),
+    body: requestBody
+  });
+  try {
+    const accept = (req.headers.get("accept") || "").toLowerCase();
+    const wantsSSE = accept.includes("text/event-stream");
+    const targetPathname = new URL(entry.targetUrl).pathname;
+    const upstreamLooksLikeSse = /\/sse(\/|$)/i.test(targetPathname);
+    if (req.method === "HEAD" && wantsSSE && !upstreamLooksLikeSse) {
+      const headers = new Headers({
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      headers.delete("content-length");
+      headers.delete("Content-Length");
+      headers.delete("transfer-encoding");
+      headers.delete("Transfer-Encoding");
+      return withCORS(new Response(null, { status: 200, headers }));
+    }
+    if (req.method === "GET" && wantsSSE && !upstreamLooksLikeSse) {
+      const xfProto = req.headers.get("x-forwarded-proto");
+      const xfHost = req.headers.get("x-forwarded-host");
+      const host = xfHost || req.headers.get("host");
+      let proto = xfProto;
+      if (!proto) {
+        const originHeader = req.headers.get("origin");
+        if (originHeader && /^https:/i.test(originHeader)) proto = "https";
+      }
+      if (!proto) proto = "http";
+      const proxyOrigin = host ? `${proto}://${host}` : new URL(req.url).origin;
+      const sessionId = crypto.randomUUID();
+      interceptorStore.setSessionEndpoint(
+        id,
+        sessionId,
+        new URL(entry.targetUrl).toString()
+      );
+      const encoder = new TextEncoder();
+      const stream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(encoder.encode(`event: ping
+`));
+          controller.enqueue(encoder.encode(`data: 
+
+`));
+          const endpoint = `${proxyOrigin}/api/mcp/interceptor/${id}/proxy/messages?sessionId=${sessionId}`;
+          const ua = c.req.header("user-agent") || "";
+          const isClaude = /claude/i.test(ua) || /anthropic/i.test(ua);
+          if (!isClaude) {
+            controller.enqueue(encoder.encode(`event: endpoint
+`));
+            controller.enqueue(
+              encoder.encode(`data: ${JSON.stringify({ url: endpoint })}
+
+`)
+            );
+          }
+          controller.enqueue(encoder.encode(`event: endpoint
+`));
+          controller.enqueue(encoder.encode(`data: ${endpoint}
+
+`));
+          const t = setInterval(() => {
+            try {
+              controller.enqueue(
+                encoder.encode(`: keepalive ${Date.now()}
+
+`)
+              );
+            } catch {
+            }
+          }, 15e3);
+          controller._t = t;
+        },
+        cancel() {
+          try {
+            clearInterval(this._t);
+          } catch {
+          }
+        }
+      });
+      {
+        const headers = new Headers({
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive",
+          "X-Accel-Buffering": "no"
+        });
+        headers.delete("content-length");
+        headers.delete("Content-Length");
+        headers.delete("transfer-encoding");
+        headers.delete("Transfer-Encoding");
+        return withCORS(new Response(stream, { headers }));
+      }
+    }
+  } catch {
+  }
+  let upstreamUrl = new URL(entry.targetUrl);
+  try {
+    const originalUrl = new URL(req.url);
+    const proxyBase = `/api/mcp/interceptor/${id}/proxy`;
+    const rest = originalUrl.pathname.startsWith(proxyBase) ? originalUrl.pathname.slice(proxyBase.length) : "";
+    const basePath = upstreamUrl.pathname.endsWith("/") ? upstreamUrl.pathname.slice(0, -1) : upstreamUrl.pathname;
+    const trailing = rest ? rest.startsWith("/") ? rest : `/${rest}` : "";
+    if (trailing.startsWith("/messages")) {
+      const sessionId = new URL(req.url).searchParams.get("sessionId") || "";
+      const mapped = sessionId ? interceptorStore.getSessionEndpoint(id, sessionId) : void 0;
+      if (mapped) {
+        upstreamUrl = new URL(mapped);
+      } else {
+        upstreamUrl.pathname = `${basePath}`;
+        upstreamUrl.search = "";
+      }
+    } else {
+      upstreamUrl.pathname = `${basePath}${trailing}`;
+      const targetParams = new URLSearchParams(upstreamUrl.search);
+      const requestParams = new URLSearchParams(originalUrl.search);
+      requestParams.forEach((value, key) => {
+        if (!targetParams.has(key)) {
+          targetParams.set(key, value);
+        }
+      });
+      upstreamUrl.search = targetParams.toString();
+    }
+  } catch {
+  }
+  const filtered = new Headers();
+  req.headers.forEach((value, key) => {
+    const k = key.toLowerCase();
+    if ([
+      "connection",
+      "keep-alive",
+      "transfer-encoding",
+      "upgrade",
+      "proxy-authenticate",
+      "proxy-authorization",
+      "te",
+      "trailer"
+    ].includes(k))
+      return;
+    if (k === "content-length") return;
+    if (k === "host") return;
+    filtered.set(key, value);
+  });
+  try {
+    const acc = (filtered.get("accept") || "").toLowerCase();
+    const hasJson = acc.includes("application/json");
+    const hasSse = acc.includes("text/event-stream");
+    if (!hasJson || !hasSse) {
+      const parts = [];
+      if (!hasJson) parts.push("application/json");
+      if (!hasSse) parts.push("text/event-stream");
+      const suffix = parts.join(", ");
+      filtered.set("accept", acc ? `${acc}, ${suffix}` : suffix);
+    }
+  } catch {
+  }
+  if (entry.injectHeaders) {
+    for (const [key, value] of Object.entries(entry.injectHeaders)) {
+      const k = key.toLowerCase();
+      if (k === "host" || k === "content-length") continue;
+      if ([
+        "connection",
+        "keep-alive",
+        "transfer-encoding",
+        "upgrade",
+        "proxy-authenticate",
+        "proxy-authorization",
+        "te",
+        "trailer"
+      ].includes(k))
+        continue;
+      if (k === "authorization" && filtered.has("authorization")) continue;
+      filtered.set(key, value);
+    }
+  }
+  const init = {
+    method: req.method,
+    headers: filtered
+  };
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    init.body = requestBody;
+  }
+  const targetReq = new Request(upstreamUrl.toString(), init);
+  try {
+    const res = await fetch(targetReq);
+    const resClone = res.clone();
+    const ct = (res.headers.get("content-type") || "").toLowerCase();
+    const isStreaming = ct.includes("text/event-stream") || ct.includes("application/x-ndjson");
+    let responseBody;
+    try {
+      if (ct.includes("text/event-stream") || ct.includes("application/x-ndjson")) {
+        responseBody = "[stream]";
+      } else {
+        responseBody = await resClone.text();
+      }
+    } catch {
+      responseBody = void 0;
+    }
+    if (!isStreaming) {
+      interceptorStore.appendLog(id, {
+        id: `${requestId}-res`,
+        timestamp: Date.now(),
+        direction: "response",
+        status: res.status,
+        statusText: res.statusText,
+        headers: Object.fromEntries(res.headers.entries()),
+        body: responseBody
+      });
+    }
+    if (ct.includes("text/event-stream")) {
+      const upstreamBody = res.body;
+      if (!upstreamBody) {
+        return withCORS(
+          new Response(null, { status: res.status, headers: res.headers })
+        );
+      }
+      const encoder = new TextEncoder();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let lastEventType = null;
+      let currentEventData = [];
+      const proxyBasePath = `/api/mcp/interceptor/${id}/proxy`;
+      const xfProto = c.req.header("x-forwarded-proto");
+      const xfHost = c.req.header("x-forwarded-host");
+      const reqHost = xfHost || c.req.header("host");
+      let reqProto = xfProto;
+      if (!reqProto) {
+        const originHeader = c.req.header("origin");
+        if (originHeader && /^https:/i.test(originHeader)) reqProto = "https";
+      }
+      if (!reqProto) reqProto = "http";
+      const proxyOrigin = reqHost ? `${reqProto}://${reqHost}` : new URL(c.req.url).origin;
+      let upstreamOrigin = (() => {
+        try {
+          const u = new URL(res.url || upstreamUrl.toString());
+          return `${u.protocol}//${u.host}`;
+        } catch {
+          try {
+            return new URL(entry.targetUrl).origin;
+          } catch {
+            return "";
+          }
+        }
+      })();
+      const rewriteStream = new ReadableStream({
+        async start(controller) {
+          const reader = upstreamBody.getReader();
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              buffer += decoder.decode(value, { stream: true });
+              let idx;
+              while ((idx = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.slice(0, idx + 1);
+                buffer = buffer.slice(idx + 1);
+                if (line.startsWith("event:")) {
+                  lastEventType = line.slice(6).trim();
+                  controller.enqueue(encoder.encode(line));
+                } else if (line.startsWith("data:")) {
+                  const rawLine = line.slice(5);
+                  const trimmed = rawLine.trim();
+                  currentEventData.push(trimmed);
+                  let endpointUrl = null;
+                  try {
+                    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+                      const obj = JSON.parse(trimmed);
+                      endpointUrl = obj?.url || obj?.endpoint?.url || obj?.type === "endpoint" && (obj?.data?.url || obj?.data);
+                    }
+                  } catch {
+                  }
+                  if (!endpointUrl) {
+                    const str = trimmed;
+                    if (/message\?/.test(str) || /messages\?/.test(str)) {
+                      endpointUrl = str;
+                    }
+                  }
+                  if (endpointUrl) {
+                    try {
+                      const u = new URL(
+                        endpointUrl,
+                        upstreamOrigin || void 0
+                      );
+                      const sessionId = u.searchParams.get("sessionId") || u.searchParams.get("sid") || "";
+                      if (sessionId) {
+                        interceptorStore.setSessionEndpoint(
+                          id,
+                          sessionId,
+                          u.toString()
+                        );
+                        try {
+                          console.log("[proxy] mapped session", {
+                            id,
+                            sessionId,
+                            upstream: u.toString()
+                          });
+                        } catch {
+                        }
+                      }
+                      const proxyEndpoint = `${proxyOrigin}${proxyBasePath}/messages${u.search}`;
+                      controller.enqueue(encoder.encode(`event: endpoint
+`));
+                      controller.enqueue(
+                        encoder.encode(`data: ${proxyEndpoint}
+
+`)
+                      );
+                      currentEventData = [];
+                      continue;
+                    } catch {
+                    }
+                  }
+                  controller.enqueue(encoder.encode(line));
+                } else if (line === "\n") {
+                  if (lastEventType === "message") {
+                    const dataText = currentEventData.join("\n");
+                    let bodyText = dataText;
+                    try {
+                      const parsed = JSON.parse(dataText);
+                      bodyText = JSON.stringify(parsed);
+                    } catch {
+                    }
+                    try {
+                      interceptorStore.appendLog(id, {
+                        id: `${requestId}-sse-${Date.now()}`,
+                        timestamp: Date.now(),
+                        direction: "response",
+                        status: 200,
+                        statusText: "SSE message",
+                        headers: { "content-type": "text/event-stream" },
+                        body: bodyText
+                      });
+                    } catch {
+                    }
+                  }
+                  currentEventData = [];
+                  lastEventType = null;
+                  controller.enqueue(encoder.encode(line));
+                } else {
+                  controller.enqueue(encoder.encode(line));
+                }
+              }
+            }
+            if (buffer.length) controller.enqueue(encoder.encode(buffer));
+          } finally {
+            try {
+              controller.close();
+            } catch {
+            }
+          }
+        }
+      });
+      const headers = new Headers(res.headers);
+      headers.delete("content-length");
+      headers.delete("Content-Length");
+      headers.delete("transfer-encoding");
+      headers.delete("Transfer-Encoding");
+      headers.set("Cache-Control", "no-cache");
+      headers.set("Connection", "keep-alive");
+      return withCORS(
+        new Response(rewriteStream, {
+          status: res.status,
+          statusText: res.statusText,
+          headers
+        })
+      );
+    }
+    const nonSseHeaders = new Headers(res.headers);
+    nonSseHeaders.delete("content-length");
+    nonSseHeaders.delete("Content-Length");
+    const passthrough = new Response(res.body, {
+      status: res.status,
+      statusText: res.statusText,
+      headers: nonSseHeaders
+    });
+    return withCORS(passthrough);
+  } catch (error) {
+    const body = JSON.stringify({ error: String(error) });
+    interceptorStore.appendLog(id, {
+      id: `${requestId}-err`,
+      timestamp: Date.now(),
+      direction: "response",
+      status: 500,
+      statusText: "Proxy Error",
+      headers: { "content-type": "application/json" },
+      body
+    });
+    return withCORS(
+      new Response(body, {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      })
+    );
+  }
+}
+interceptor.all("/:id/proxy", handleProxy);
+interceptor.all("/:id/proxy/*", handleProxy);
+var interceptor_default = interceptor;
+
+// routes/mcp/http-adapters.ts
+import { Hono as Hono11 } from "hono";
+
+// services/mcp-http-bridge.ts
+import { z as z11 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema4 } from "zod-to-json-schema";
+function buildInitializeResult(serverId, mode) {
+  if (mode === "adapter") {
+    return {
+      protocolVersion: "2025-06-18",
+      capabilities: {
+        tools: { listChanged: true },
+        prompts: {},
+        resources: { listChanged: true, subscribe: true },
+        logging: {},
+        roots: { listChanged: true }
+      },
+      serverInfo: { name: serverId, version: "stdio-adapter" }
+    };
+  }
+  return {
+    protocolVersion: "2025-06-18",
+    capabilities: {
+      tools: true,
+      prompts: true,
+      resources: true,
+      logging: false,
+      elicitation: {},
+      roots: { listChanged: true }
+    },
+    serverInfo: { name: serverId, version: "mcpjam-proxy" }
+  };
+}
+function toJsonSchemaMaybe(schema) {
+  try {
+    if (schema && typeof schema === "object") {
+      if (schema instanceof z11.ZodType || "_def" in schema && "parse" in schema) {
+        return zodToJsonSchema4(schema);
+      }
+    }
+  } catch {
+  }
+  return schema;
+}
+async function handleJsonRpc(serverId, body, clientManager, mode) {
+  const id = body?.id ?? null;
+  const method = body?.method;
+  const params = body?.params ?? {};
+  if (!method || method.startsWith("notifications/")) {
+    return null;
+  }
+  const respond = (payload) => ({ jsonrpc: "2.0", id, ...payload });
+  try {
+    switch (method) {
+      case "ping":
+        return respond({ result: {} });
+      case "initialize": {
+        const result = buildInitializeResult(serverId, mode);
+        return respond({ result });
+      }
+      case "tools/list": {
+        const toolsets = await clientManager.getToolsetsForServer(serverId);
+        const tools2 = Object.keys(toolsets).map((name17) => ({
+          name: name17,
+          description: toolsets[name17].description,
+          inputSchema: toJsonSchemaMaybe(toolsets[name17].inputSchema),
+          outputSchema: toJsonSchemaMaybe(toolsets[name17].outputSchema)
+        }));
+        return respond({ result: { tools: tools2 } });
+      }
+      case "tools/call": {
+        try {
+          const exec = await clientManager.executeToolDirect(
+            `${serverId}:${params?.name}`,
+            params?.arguments || {}
+          );
+          if (mode === "manager") {
+            const result = {
+              content: [
+                {
+                  type: "text",
+                  text: typeof exec.result === "string" ? exec.result : JSON.stringify(exec.result, null, 2)
+                }
+              ],
+              isError: false
+            };
+            return respond({ result });
+          }
+          return respond({ result: exec.result });
+        } catch (e) {
+          if (mode === "manager") {
+            const result = {
+              content: [
+                { type: "text", text: `Error: ${e?.message || String(e)}` }
+              ],
+              isError: true
+            };
+            return respond({ result });
+          }
+          return respond({
+            error: { code: -32e3, message: e?.message || String(e) }
+          });
+        }
+      }
+      case "resources/list": {
+        const resources2 = clientManager.getResourcesForServer(serverId).map((r) => ({
+          uri: r.uri,
+          name: r.name,
+          description: r.description,
+          mimeType: r.mimeType
+        }));
+        return respond({ result: { resources: resources2 } });
+      }
+      case "resources/read": {
+        try {
+          const content = await clientManager.getResource(
+            params?.uri,
+            serverId
+          );
+          if (mode === "manager") {
+            const result = {
+              contents: [
+                {
+                  uri: params?.uri,
+                  mimeType: content?.mimeType || "text/plain",
+                  text: typeof content === "string" ? content : JSON.stringify(content, null, 2)
+                }
+              ]
+            };
+            return respond({ result });
+          }
+          return respond({ result: content });
+        } catch (e) {
+          return respond({
+            error: { code: -32e3, message: e?.message || String(e) }
+          });
+        }
+      }
+      case "prompts/list": {
+        const prompts2 = clientManager.getPromptsForServer(serverId).map((p) => ({
+          name: p.name,
+          description: p.description,
+          arguments: p.arguments
+        }));
+        return respond({ result: { prompts: prompts2 } });
+      }
+      case "prompts/get": {
+        try {
+          const content = await clientManager.getPrompt(
+            params?.name,
+            serverId,
+            params?.arguments || {}
+          );
+          if (mode === "manager") {
+            const result = {
+              description: content?.description || `Prompt: ${params?.name}`,
+              messages: [
+                {
+                  role: "user",
+                  content: {
+                    type: "text",
+                    text: typeof content === "string" ? content : JSON.stringify(content, null, 2)
+                  }
+                }
+              ]
+            };
+            return respond({ result });
+          }
+          return respond({ result: content });
+        } catch (e) {
+          return respond({
+            error: { code: -32e3, message: e?.message || String(e) }
+          });
+        }
+      }
+      case "roots/list": {
+        return respond({ result: { roots: [] } });
+      }
+      case "logging/setLevel": {
+        return respond({ result: { success: true } });
+      }
+      default: {
+        return respond({
+          error: { code: -32601, message: `Method not implemented: ${method}` }
+        });
+      }
+    }
+  } catch (e) {
+    return respond({
+      error: { code: -32e3, message: e?.message || String(e) }
+    });
+  }
+}
+
+// routes/mcp/http-adapters.ts
+var sessions = /* @__PURE__ */ new Map();
+var latestSessionByServer = /* @__PURE__ */ new Map();
+function createHttpHandler(mode, routePrefix) {
+  const router = new Hono11();
+  router.options(
+    "/:serverId",
+    (c) => c.body(null, 204, {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET,POST,HEAD,OPTIONS",
+      "Access-Control-Allow-Headers": "*, Authorization, Content-Type, Accept, Accept-Language",
+      "Access-Control-Expose-Headers": "*",
+      "Access-Control-Max-Age": "86400"
+    })
+  );
+  router.options(
+    "/:serverId/*",
+    (c) => c.body(null, 204, {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET,POST,HEAD,OPTIONS",
+      "Access-Control-Allow-Headers": "*, Authorization, Content-Type, Accept, Accept-Language",
+      "Access-Control-Expose-Headers": "*",
+      "Access-Control-Max-Age": "86400"
+    })
+  );
+  async function handleHttp(c) {
+    const serverId = c.req.param("serverId");
+    const method = c.req.method;
+    if (method === "HEAD") {
+      return c.body(null, 200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Access-Control-Allow-Origin": "*",
+        "X-Accel-Buffering": "no"
+      });
+    }
+    if (method === "GET") {
+      const encoder = new TextEncoder();
+      const incomingUrl = new URL(c.req.url);
+      const overrideBase = c.req.header("x-mcpjam-endpoint-base");
+      let endpointBase;
+      if (overrideBase && overrideBase.trim() !== "") {
+        endpointBase = overrideBase.trim();
+      } else {
+        const xfProto = c.req.header("x-forwarded-proto");
+        const xfHost = c.req.header("x-forwarded-host");
+        const host = xfHost || c.req.header("host");
+        let proto = xfProto;
+        if (!proto) {
+          const originHeader = c.req.header("origin");
+          if (originHeader && /^https:/i.test(originHeader)) proto = "https";
+        }
+        if (!proto) proto = "http";
+        const origin = host ? `${proto}://${host}` : incomingUrl.origin;
+        endpointBase = `${origin}/api/mcp/${routePrefix}/${serverId}/messages`;
+      }
+      const sessionId = crypto.randomUUID();
+      let timer;
+      const stream = new ReadableStream({
+        start(controller) {
+          console.log(`[${routePrefix}] SSE open`, { serverId, sessionId });
+          const send = (event, data) => {
+            controller.enqueue(encoder.encode(`event: ${event}
+`));
+            controller.enqueue(encoder.encode(`data: ${data}
+
+`));
+          };
+          const close = () => {
+            try {
+              controller.close();
+            } catch {
+            }
+          };
+          sessions.set(`${serverId}:${sessionId}`, { send, close });
+          latestSessionByServer.set(serverId, sessionId);
+          console.log(`[${routePrefix}] session registered`, {
+            key: `${serverId}:${sessionId}`
+          });
+          send("ping", "");
+          const sep = endpointBase.includes("?") ? "&" : "?";
+          const url = `${endpointBase}${sep}sessionId=${sessionId}`;
+          console.log(`[${routePrefix}] endpoint`, {
+            serverId,
+            sessionId,
+            url
+          });
+          try {
+            send("endpoint", JSON.stringify({ url, headers: {} }));
+          } catch {
+          }
+          try {
+            send("endpoint", url);
+          } catch {
+          }
+          timer = setInterval(() => {
+            try {
+              controller.enqueue(
+                encoder.encode(`: keepalive ${Date.now()}
+
+`)
+              );
+            } catch {
+            }
+          }, 15e3);
+        },
+        cancel() {
+          try {
+            clearInterval(timer);
+          } catch {
+          }
+          console.log(`[${routePrefix}] SSE close`, { serverId, sessionId });
+          sessions.delete(`${serverId}:${sessionId}`);
+          if (latestSessionByServer.get(serverId) === sessionId) {
+            latestSessionByServer.delete(serverId);
+          }
+        }
+      });
+      return c.body(stream, 200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Expose-Headers": "*",
+        "X-Accel-Buffering": "no",
+        "Transfer-Encoding": "chunked"
+      });
+    }
+    if (method !== "POST") {
+      return c.json({ error: "Unsupported request" }, 400);
+    }
+    let body = void 0;
+    try {
+      body = await c.req.json();
+    } catch {
+    }
+    const clientManager = c.mcpJamClientManager;
+    const response = await handleJsonRpc(
+      serverId,
+      body,
+      clientManager,
+      mode
+    );
+    if (!response) {
+      return c.body("Accepted", 202, { "Access-Control-Allow-Origin": "*" });
+    }
+    return c.body(JSON.stringify(response), 200, {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Expose-Headers": "*"
+    });
+  }
+  router.post("/:serverId/messages", async (c) => {
+    const serverId = c.req.param("serverId");
+    const url = new URL(c.req.url);
+    const sessionId = url.searchParams.get("sessionId") || "";
+    const key = `${serverId}:${sessionId}`;
+    let sess = sessions.get(key);
+    if (!sess) {
+      const fallbackId = latestSessionByServer.get(serverId);
+      if (fallbackId) {
+        sess = sessions.get(`${serverId}:${fallbackId}`);
+      }
+    }
+    console.log(`[${routePrefix}] POST messages`, {
+      key,
+      resolved: !!sess,
+      contentType: c.req.header("content-type")
+    });
+    if (!sess) {
+      return c.json({ error: "Invalid session" }, 400);
+    }
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      try {
+        const txt = await c.req.text();
+        body = txt ? JSON.parse(txt) : void 0;
+      } catch {
+        body = void 0;
+      }
+    }
+    const id = body?.id ?? null;
+    const method = body?.method;
+    const params = body?.params ?? {};
+    try {
+      const responseMessage = await handleJsonRpc(
+        serverId,
+        { id, method, params },
+        c.mcpJamClientManager,
+        mode
+      );
+      if (responseMessage) {
+        try {
+          console.log(`[${routePrefix}] emit message`, {
+            key,
+            id: responseMessage.id,
+            method
+          });
+          sess.send("message", JSON.stringify(responseMessage));
+        } catch {
+        }
+      }
+      return c.body("Accepted", 202, {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Expose-Headers": "*"
+      });
+    } catch (e) {
+      return c.body("Error", 400, {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Expose-Headers": "*"
+      });
+    }
+  });
+  router.all("/:serverId", handleHttp);
+  router.all("/:serverId/*", handleHttp);
+  return router;
+}
+var adapterHttp = createHttpHandler("adapter", "adapter-http");
+var managerHttp = createHttpHandler("manager", "manager-http");
+
 // routes/mcp/index.ts
-var mcp = new Hono10();
+var mcp = new Hono12();
 mcp.get("/health", (c) => {
   return c.json({
     service: "MCP API",
@@ -3999,6 +5298,9 @@ mcp.route("/resources", resources_default);
 mcp.route("/prompts", prompts_default);
 mcp.route("/oauth", oauth_default);
 mcp.route("/export", export_default);
+mcp.route("/interceptor", interceptor_default);
+mcp.route("/adapter-http", adapterHttp);
+mcp.route("/manager-http", managerHttp);
 var mcp_default = mcp;
 
 // services/mcpjam-client-manager.ts
@@ -4284,6 +5586,7 @@ var MCPJamClientManager = class {
     let lastError = void 0;
     for (const args of attempts) {
       try {
+        console.log("args", args);
         const result = await tool.execute(args);
         if (result && result.isError) {
           const errorText = result.content && result.content[0] && result.content[0].text ? result.content[0].text : "Unknown error";
@@ -4452,7 +5755,7 @@ try {
   fixPath();
 } catch {
 }
-var app = new Hono11();
+var app = new Hono13();
 var mcpJamClientManager = new MCPJamClientManager();
 app.use("*", async (c, next) => {
   c.mcpJamClientManager = mcpJamClientManager;
@@ -4473,6 +5776,95 @@ app.use(
   })
 );
 app.route("/api/mcp", mcp_default);
+app.options("/sse/message", (c) => {
+  return c.body(null, 204, {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "POST,OPTIONS",
+    "Access-Control-Allow-Headers": "Authorization, Content-Type, Accept, Accept-Language",
+    "Access-Control-Max-Age": "86400",
+    Vary: "Origin, Access-Control-Request-Headers"
+  });
+});
+app.post("/sse/message", async (c) => {
+  try {
+    const url = new URL(c.req.url);
+    const sessionId = url.searchParams.get("sessionId") || url.searchParams.get("sid") || "";
+    if (!sessionId) {
+      return c.json({ error: "Missing sessionId" }, 400);
+    }
+    const mapping = interceptorStore.getSessionMapping(sessionId);
+    if (!mapping) {
+      return c.json({ error: "Unknown sessionId" }, 404);
+    }
+    const entry = interceptorStore.get(mapping.interceptorId);
+    if (!entry) {
+      return c.json({ error: "Interceptor not found" }, 404);
+    }
+    let bodyText = "";
+    try {
+      bodyText = await c.req.text();
+    } catch {
+    }
+    const headers = new Headers();
+    c.req.raw.headers.forEach((v, k) => {
+      const key = k.toLowerCase();
+      if ([
+        "connection",
+        "keep-alive",
+        "transfer-encoding",
+        "upgrade",
+        "proxy-authenticate",
+        "proxy-authorization",
+        "te",
+        "trailer",
+        "host",
+        "content-length"
+      ].includes(key))
+        return;
+      headers.set(k, v);
+    });
+    if (entry.injectHeaders) {
+      for (const [k, v] of Object.entries(entry.injectHeaders)) {
+        const key = k.toLowerCase();
+        if ([
+          "connection",
+          "keep-alive",
+          "transfer-encoding",
+          "upgrade",
+          "proxy-authenticate",
+          "proxy-authorization",
+          "te",
+          "trailer",
+          "host",
+          "content-length"
+        ].includes(key))
+          continue;
+        if (key === "authorization" && headers.has("authorization")) continue;
+        headers.set(k, v);
+      }
+    }
+    try {
+      await fetch(
+        new Request(mapping.url, { method: "POST", headers, body: bodyText })
+      );
+    } catch {
+    }
+    return c.body("Accepted", 202, {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Expose-Headers": "*"
+    });
+  } catch (e) {
+    return c.body(
+      JSON.stringify({ error: e?.message || "Forward error" }),
+      400,
+      {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Expose-Headers": "*"
+      }
+    );
+  }
+});
 app.get("/health", (c) => {
   return c.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
 });
@@ -4481,6 +5873,11 @@ app.get("/api/mcp-cli-config", (c) => {
   return c.json({ config: mcpConfig });
 });
 if (process.env.NODE_ENV === "production") {
+  app.use("/*.png", serveStatic({ root: "./public" }));
+  app.use("/*.svg", serveStatic({ root: "./public" }));
+  app.use("/*.jpg", serveStatic({ root: "./public" }));
+  app.use("/*.jpeg", serveStatic({ root: "./public" }));
+  app.use("/*.ico", serveStatic({ root: "./public" }));
   app.use("/*", serveStatic({ root: "./dist/client" }));
   app.get("*", async (c) => {
     const path = c.req.path;