@mcp-use/inspector 12.0.4-canary.0 → 20.0.0-beta.0

package/dist/server/chunk-PJNKFX2R.js

@@ -1,2351 +0,0 @@
-// src/llm/toolResultParts.ts
-function makeText(text) {
-  return { type: "text", text };
-}
-function makeImage(data, mimeType) {
-  return {
-    type: "image",
-    url: `data:${mimeType};base64,${data}`,
-    mimeType,
-    data
-  };
-}
-function isMcpResultShape(value) {
-  if (!value || typeof value !== "object") return false;
-  const v = value;
-  if (Array.isArray(v.content)) return true;
-  return "structuredContent" in v;
-}
-function isToolResultError(result) {
-  return typeof result === "object" && result !== null && result.isError === true;
-}
-function blockToPart(block) {
-  if (!block || typeof block !== "object") return null;
-  switch (block.type) {
-    case "text": {
-      const text = block.text;
-      return typeof text === "string" && text.length > 0 ? makeText(text) : null;
-    }
-    case "image": {
-      const b = block;
-      if (typeof b.data !== "string" || !b.data) return null;
-      const mime = typeof b.mimeType === "string" && b.mimeType ? b.mimeType : "image/png";
-      return makeImage(b.data, mime);
-    }
-    case "audio": {
-      const b = block;
-      const mime = typeof b.mimeType === "string" && b.mimeType ? b.mimeType : "audio/*";
-      const bytes = typeof b.data === "string" ? b.data.length : 0;
-      return makeText(`[audio: ${mime}, base64 omitted (${bytes} chars)]`);
-    }
-    case "resource": {
-      const r = block.resource ?? {};
-      if (typeof r.text === "string" && r.text.length > 0) {
-        return makeText(r.text);
-      }
-      if (typeof r.blob === "string" && typeof r.mimeType === "string" && r.mimeType.startsWith("image/")) {
-        return makeImage(r.blob, r.mimeType);
-      }
-      const uri = typeof r.uri === "string" ? r.uri : "<unknown>";
-      const mime = typeof r.mimeType === "string" ? r.mimeType : "unknown";
-      return makeText(`[resource: ${uri} (${mime})]`);
-    }
-    case "resource_link": {
-      const b = block;
-      const uri = typeof b.uri === "string" ? b.uri : "<unknown>";
-      const name = typeof b.name === "string" ? ` "${b.name}"` : "";
-      return makeText(`[resource_link${name}: ${uri}]`);
-    }
-    default: {
-      return makeText(
-        `[unsupported tool content block: ${String(block.type)}]`
-      );
-    }
-  }
-}
-function stripMeta(value) {
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    const { _meta: _ignored, ...rest } = value;
-    return rest;
-  }
-  return value;
-}
-function extractToolResultParts(result) {
-  const stripped = stripMeta(result);
-  if (typeof stripped === "string") {
-    return stripped.length > 0 ? [makeText(stripped)] : [];
-  }
-  if (isMcpResultShape(stripped)) {
-    const r = stripped;
-    const parts = [];
-    if (Array.isArray(r.content)) {
-      for (const block of r.content) {
-        const p = blockToPart(block);
-        if (p) parts.push(p);
-      }
-    }
-    if (r.structuredContent !== void 0) {
-      try {
-        parts.push(
-          makeText(`structuredContent: ${JSON.stringify(r.structuredContent)}`)
-        );
-      } catch {
-      }
-    }
-    if (r.isError) {
-      parts.unshift(makeText("[tool reported isError=true]"));
-    }
-    return parts;
-  }
-  try {
-    return [makeText(JSON.stringify(stripped))];
-  } catch {
-    return [makeText(String(stripped))];
-  }
-}
-function collapseToString(parts) {
-  if (parts.length === 0) return "";
-  if (parts.every((p) => p.type === "text")) {
-    return parts.map((p) => p.text).join("\n");
-  }
-  return null;
-}
-function toolResultToContent(result) {
-  const parts = extractToolResultParts(result);
-  const collapsed = collapseToString(parts);
-  return collapsed !== null ? collapsed : parts;
-}
-function partitionToolContent(content) {
-  if (typeof content === "string") {
-    return { text: content, imageParts: [], isString: true };
-  }
-  const texts = [];
-  const imageParts = [];
-  for (const p of content) {
-    if (p.type === "text") {
-      if (p.text) texts.push(p.text);
-    } else if (p.type === "image") {
-      imageParts.push(p);
-    }
-  }
-  return { text: texts.join("\n"), imageParts, isString: false };
-}
-function toolImageFollowupHeader(toolName, count) {
-  return `(Tool "${toolName ?? "<tool>"}" returned the following image${count === 1 ? "" : "s"}:)`;
-}
-
-// src/llm/messageFormat.ts
-function extractText(m) {
-  const raw = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((x) => x?.text ?? "").join("\n") : JSON.stringify(m.content ?? "");
-  if (raw.trim()) return raw.trim();
-  if (m.parts?.length) {
-    return m.parts.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("").trim();
-  }
-  return "";
-}
-function convertMessagesToProvider(messages) {
-  const out = [];
-  messages.forEach((m, mi) => {
-    if (m.role === "user") {
-      const text2 = extractText(m) || "[no content]";
-      if (m.attachments?.length) {
-        const parts = [{ type: "text", text: text2 }];
-        for (const a of m.attachments) {
-          if (a.type === "image") {
-            parts.push({
-              type: "image",
-              url: `data:${a.mimeType};base64,${a.data}`,
-              mimeType: a.mimeType,
-              data: a.data
-            });
-          }
-        }
-        out.push({ role: "user", content: parts });
-      } else {
-        out.push({ role: "user", content: text2 });
-      }
-      return;
-    }
-    const toolParts = (m.parts ?? []).filter(
-      (p) => p.type === "tool-invocation" && p.toolInvocation && p.toolInvocation.result !== void 0
-    );
-    if (toolParts.length === 0) {
-      const text2 = extractText(m) || "[no content]";
-      out.push({ role: "assistant", content: text2 });
-      return;
-    }
-    const text = extractText(m);
-    const toolCalls = toolParts.map((p, i) => ({
-      id: `call_${mi}_${i}_${p.toolInvocation.toolName}`,
-      name: p.toolInvocation.toolName,
-      args: p.toolInvocation.args
-    }));
-    out.push({
-      role: "assistant",
-      content: text,
-      toolCalls
-    });
-    toolParts.forEach((p, i) => {
-      const result = p.toolInvocation.result;
-      out.push({
-        role: "tool",
-        content: toolResultToContent(result),
-        toolCallId: `call_${mi}_${i}_${p.toolInvocation.toolName}`,
-        toolName: p.toolInvocation.toolName,
-        toolResult: result,
-        toolIsError: isToolResultError(result)
-      });
-    });
-  });
-  return out;
-}
-function extractSystem(messages) {
-  const sys = [];
-  const rest = [];
-  for (const m of messages) {
-    if (m.role === "system") {
-      if (typeof m.content === "string") sys.push(m.content);
-      else if (Array.isArray(m.content)) {
-        for (const p of m.content) if (p.type === "text") sys.push(p.text);
-      }
-    } else {
-      rest.push(m);
-    }
-  }
-  return {
-    system: sys.length > 0 ? sys.join("\n\n") : void 0,
-    rest
-  };
-}
-function parseDataUrl(url) {
-  const m = url.match(/^data:([^;,]+);base64,(.+)$/);
-  if (!m) return null;
-  return { mimeType: m[1], data: m[2] };
-}
-
-// src/llm/sse.ts
-async function* parseSSE(body, signal) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder("utf-8");
-  let buffer = "";
-  try {
-    while (true) {
-      if (signal?.aborted) return;
-      const { value, done } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      let sep;
-      while ((sep = indexOfEventSeparator(buffer)) !== -1) {
-        const raw = buffer.slice(0, sep);
-        buffer = buffer.slice(sep).replace(/^(\r\n\r\n|\n\n|\r\r)/, "");
-        const parsed = parseSseBlock(raw);
-        if (parsed) yield parsed;
-      }
-    }
-    if (buffer.trim()) {
-      const parsed = parseSseBlock(buffer);
-      if (parsed) yield parsed;
-    }
-  } finally {
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-  }
-}
-function indexOfEventSeparator(s) {
-  const a = s.indexOf("\n\n");
-  const b = s.indexOf("\r\n\r\n");
-  if (a === -1) return b;
-  if (b === -1) return a;
-  return Math.min(a, b);
-}
-function parseSseBlock(raw) {
-  let event;
-  const dataLines = [];
-  for (const line of raw.split(/\r?\n/)) {
-    if (!line || line.startsWith(":")) continue;
-    const idx = line.indexOf(":");
-    const field = idx === -1 ? line : line.slice(0, idx);
-    let value = idx === -1 ? "" : line.slice(idx + 1);
-    if (value.startsWith(" ")) value = value.slice(1);
-    if (field === "event") event = value;
-    else if (field === "data") dataLines.push(value);
-  }
-  if (dataLines.length === 0) return null;
-  return { event, data: dataLines.join("\n") };
-}
-
-// src/llm/providers/anthropic.ts
-var DEFAULT_ENDPOINT = "https://api.anthropic.com/v1/messages";
-var ANTHROPIC_VERSION = "2023-06-01";
-var DEFAULT_MAX_TOKENS = 4096;
-function buildImageBlock(p) {
-  if (p.type !== "image") return null;
-  if (p.data && p.mimeType) {
-    return {
-      type: "image",
-      source: { type: "base64", media_type: p.mimeType, data: p.data }
-    };
-  }
-  const parsed = parseDataUrl(p.url);
-  if (parsed) {
-    return {
-      type: "image",
-      source: {
-        type: "base64",
-        media_type: parsed.mimeType,
-        data: parsed.data
-      }
-    };
-  }
-  return { type: "image", source: { type: "url", url: p.url } };
-}
-function toAnthropicContent(content) {
-  if (typeof content === "string") {
-    return [{ type: "text", text: content || "[no content]" }];
-  }
-  const blocks = [];
-  for (const p of content) {
-    if (p.type === "text") {
-      if (p.text) blocks.push({ type: "text", text: p.text });
-    } else {
-      const img = buildImageBlock(p);
-      if (img) blocks.push(img);
-    }
-  }
-  if (blocks.length === 0) blocks.push({ type: "text", text: "[no content]" });
-  return blocks;
-}
-function toAnthropicToolResultContent(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  const blocks = [];
-  for (const p of content) {
-    if (p.type === "text") {
-      if (p.text) blocks.push({ type: "text", text: p.text });
-    } else if (p.type === "image") {
-      const img = buildImageBlock(p);
-      if (img) blocks.push(img);
-    }
-  }
-  if (blocks.length === 0) {
-    return "[no content]";
-  }
-  return blocks;
-}
-function toAnthropicMessages(messages) {
-  const out = [];
-  for (const m of messages) {
-    if (m.role === "tool") {
-      const last = out[out.length - 1];
-      const block = {
-        type: "tool_result",
-        tool_use_id: m.toolCallId,
-        content: toAnthropicToolResultContent(m.content),
-        ...m.toolIsError ? { is_error: true } : {}
-      };
-      if (last && last.role === "user" && Array.isArray(last.content)) {
-        last.content.push(block);
-      } else {
-        out.push({ role: "user", content: [block] });
-      }
-      continue;
-    }
-    if (m.role === "assistant") {
-      const blocks = [];
-      const textContent = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((p) => p.type === "text" ? p.text : "").join("") : "";
-      if (textContent) blocks.push({ type: "text", text: textContent });
-      if (m.toolCalls?.length) {
-        for (const tc of m.toolCalls) {
-          blocks.push({
-            type: "tool_use",
-            id: tc.id,
-            name: tc.name,
-            input: tc.args ?? {}
-          });
-        }
-      }
-      if (blocks.length === 0) {
-        blocks.push({ type: "text", text: "[no content]" });
-      }
-      out.push({ role: "assistant", content: blocks });
-      continue;
-    }
-    out.push({ role: "user", content: toAnthropicContent(m.content) });
-  }
-  return out;
-}
-function buildBody(params, stream) {
-  const { config, messages, tools } = params;
-  const { system, rest } = extractSystem(messages);
-  const body = {
-    model: config.model,
-    max_tokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
-    messages: toAnthropicMessages(rest),
-    ...stream ? { stream: true } : {}
-  };
-  if (config.temperature !== void 0) body.temperature = config.temperature;
-  if (system) body.system = system;
-  if (tools && tools.length > 0) {
-    body.tools = tools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      input_schema: t.inputSchema
-    }));
-  }
-  return body;
-}
-async function* streamChat(params) {
-  const { config, signal } = params;
-  const res = await fetch(DEFAULT_ENDPOINT, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "x-api-key": config.apiKey,
-      "anthropic-version": ANTHROPIC_VERSION,
-      "anthropic-dangerous-direct-browser-access": "true"
-    },
-    body: JSON.stringify(buildBody(params, true)),
-    signal
-  });
-  if (!res.ok || !res.body) {
-    const text = await res.text().catch(() => "");
-    throw new Error(
-      `Anthropic request failed (${res.status} ${res.statusText}): ${text}`
-    );
-  }
-  const blocks = /* @__PURE__ */ new Map();
-  for await (const ev of parseSSE(res.body, signal)) {
-    let parsed;
-    try {
-      parsed = JSON.parse(ev.data);
-    } catch {
-      continue;
-    }
-    const t = parsed?.type;
-    if (t === "content_block_start") {
-      const idx = parsed.index;
-      const cb = parsed.content_block ?? {};
-      if (cb.type === "tool_use") {
-        blocks.set(idx, {
-          kind: "tool_use",
-          id: cb.id,
-          name: cb.name,
-          argsJson: "",
-          emittedStart: false
-        });
-        yield {
-          type: "tool-call-start",
-          index: idx,
-          toolCallId: cb.id,
-          toolName: cb.name
-        };
-        const entry = blocks.get(idx);
-        if (entry) entry.emittedStart = true;
-      } else {
-        blocks.set(idx, {
-          kind: "text",
-          argsJson: "",
-          emittedStart: false
-        });
-      }
-    } else if (t === "content_block_delta") {
-      const idx = parsed.index;
-      const d = parsed.delta ?? {};
-      const entry = blocks.get(idx);
-      if (!entry) continue;
-      if (d.type === "text_delta" && typeof d.text === "string") {
-        yield { type: "text-delta", delta: d.text };
-      } else if (d.type === "input_json_delta" && typeof d.partial_json === "string" && entry.kind === "tool_use") {
-        entry.argsJson += d.partial_json;
-        yield {
-          type: "tool-call-args-delta",
-          index: idx,
-          toolCallId: entry.id,
-          toolName: entry.name,
-          argsDelta: d.partial_json
-        };
-      }
-    } else if (t === "content_block_stop") {
-      const idx = parsed.index;
-      const entry = blocks.get(idx);
-      if (entry && entry.kind === "tool_use" && entry.id && entry.name) {
-        let args = {};
-        if (entry.argsJson) {
-          try {
-            args = JSON.parse(entry.argsJson);
-          } catch {
-            args = {};
-          }
-        }
-        yield {
-          type: "tool-call-ready",
-          index: idx,
-          toolCallId: entry.id,
-          toolName: entry.name,
-          args
-        };
-      }
-    } else if (t === "message_stop") {
-    } else if (t === "error") {
-      yield {
-        type: "error",
-        message: parsed?.error?.message ?? "Anthropic stream error"
-      };
-    }
-  }
-  yield { type: "done" };
-}
-async function chat(params) {
-  const { config, signal } = params;
-  const res = await fetch(DEFAULT_ENDPOINT, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "x-api-key": config.apiKey,
-      "anthropic-version": ANTHROPIC_VERSION,
-      "anthropic-dangerous-direct-browser-access": "true"
-    },
-    body: JSON.stringify(buildBody(params, false)),
-    signal
-  });
-  if (!res.ok) {
-    const text2 = await res.text().catch(() => "");
-    throw new Error(
-      `Anthropic request failed (${res.status} ${res.statusText}): ${text2}`
-    );
-  }
-  const json = await res.json();
-  let text = "";
-  const toolCalls = [];
-  for (const block of json?.content ?? []) {
-    if (block.type === "text" && typeof block.text === "string") {
-      text += block.text;
-    } else if (block.type === "tool_use") {
-      toolCalls.push({
-        id: block.id,
-        name: block.name,
-        args: block.input && typeof block.input === "object" ? block.input : {}
-      });
-    }
-  }
-  return { text, toolCalls };
-}
-
-// src/llm/schemaUtils.ts
-var ALLOWED_KEYS = /* @__PURE__ */ new Set([
-  "type",
-  "description",
-  "enum",
-  "properties",
-  "required",
-  "items",
-  "format",
-  "nullable",
-  "minimum",
-  "maximum",
-  "minItems",
-  "maxItems",
-  "minLength",
-  "maxLength",
-  "pattern"
-]);
-function sanitizeSchemaForGemini(schema) {
-  if (!schema || typeof schema !== "object") {
-    return { type: "object" };
-  }
-  const cleaned = clean(schema);
-  if (typeof cleaned !== "object" || cleaned === null) {
-    return { type: "object" };
-  }
-  const out = cleaned;
-  if (!out.type) out.type = "object";
-  return out;
-}
-function clean(value) {
-  if (Array.isArray(value)) return value.map(clean);
-  if (!value || typeof value !== "object") return value;
-  const input = value;
-  for (const key of ["oneOf", "anyOf", "allOf"]) {
-    const arr = input[key];
-    if (Array.isArray(arr) && arr.length === 1) {
-      return clean(arr[0]);
-    }
-  }
-  const out = {};
-  for (const [k, v] of Object.entries(input)) {
-    if (!ALLOWED_KEYS.has(k)) continue;
-    if (k === "properties" && v && typeof v === "object") {
-      const props = {};
-      for (const [pk, pv] of Object.entries(v)) {
-        props[pk] = clean(pv);
-      }
-      out[k] = props;
-    } else if (k === "items") {
-      out[k] = clean(v);
-    } else {
-      out[k] = v;
-    }
-  }
-  return out;
-}
-
-// src/llm/providers/google.ts
-function normalizeModelId(model) {
-  const trimmed = model.trim();
-  return trimmed.startsWith("models/") ? trimmed.slice("models/".length) : trimmed;
-}
-function endpointFor(model, mode) {
-  const action = mode === "stream" ? "streamGenerateContent?alt=sse" : "generateContent";
-  return `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(
-    normalizeModelId(model)
-  )}:${action}`;
-}
-function buildInlineData(p) {
-  if (p.type !== "image") return null;
-  if (p.data && p.mimeType) {
-    return { inlineData: { mimeType: p.mimeType, data: p.data } };
-  }
-  const parsed = parseDataUrl(p.url);
-  if (parsed) {
-    return {
-      inlineData: { mimeType: parsed.mimeType, data: parsed.data }
-    };
-  }
-  return null;
-}
-function toGeminiParts(content) {
-  if (typeof content === "string") {
-    return [{ text: content || "[no content]" }];
-  }
-  const parts = [];
-  for (const p of content) {
-    if (p.type === "text") {
-      if (p.text) parts.push({ text: p.text });
-    } else {
-      const block = buildInlineData(p);
-      if (block) parts.push(block);
-    }
-  }
-  if (parts.length === 0) parts.push({ text: "[no content]" });
-  return parts;
-}
-function buildGeminiToolResponse(content) {
-  if (typeof content === "string") {
-    let parsed;
-    try {
-      parsed = JSON.parse(content);
-    } catch {
-      parsed = { result: content };
-    }
-    if (!parsed || typeof parsed !== "object") {
-      parsed = { result: parsed };
-    }
-    return { response: parsed, imageParts: [] };
-  }
-  const { text, imageParts } = partitionToolContent(content);
-  const response = {};
-  if (text) response.text = text;
-  if (imageParts.length > 0) {
-    response.images = imageParts.map((p) => ({
-      mimeType: p.mimeType ?? "image/*",
-      omitted: true
-    }));
-    response.note = "Image bytes were sent in the next user turn as inlineData.";
-  }
-  if (Object.keys(response).length === 0) {
-    response.result = null;
-  }
-  return { response, imageParts };
-}
-function toGeminiContents(messages) {
-  const out = [];
-  for (const m of messages) {
-    if (m.role === "tool") {
-      const { response, imageParts } = buildGeminiToolResponse(m.content);
-      const last = out[out.length - 1];
-      const part = {
-        functionResponse: {
-          name: m.toolName,
-          response
-        }
-      };
-      if (last && last.role === "function") {
-        last.parts.push(part);
-      } else {
-        out.push({ role: "function", parts: [part] });
-      }
-      if (imageParts.length > 0) {
-        const userParts = [
-          { text: toolImageFollowupHeader(m.toolName, imageParts.length) }
-        ];
-        for (const p of imageParts) {
-          const block = buildInlineData(p);
-          if (block) userParts.push(block);
-        }
-        out.push({ role: "user", parts: userParts });
-      }
-      continue;
-    }
-    if (m.role === "assistant") {
-      const parts = [];
-      const textContent = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((p) => p.type === "text" ? p.text : "").join("") : "";
-      if (textContent) parts.push({ text: textContent });
-      if (m.toolCalls?.length) {
-        for (const tc of m.toolCalls) {
-          parts.push({
-            functionCall: { name: tc.name, args: tc.args ?? {} }
-          });
-        }
-      }
-      if (parts.length === 0) parts.push({ text: "[no content]" });
-      out.push({ role: "model", parts });
-      continue;
-    }
-    out.push({ role: "user", parts: toGeminiParts(m.content) });
-  }
-  return out;
-}
-function buildBody2(params) {
-  const { config, messages, tools } = params;
-  const { system, rest } = extractSystem(messages);
-  const body = {
-    contents: toGeminiContents(rest)
-  };
-  if (system) {
-    body.systemInstruction = { parts: [{ text: system }] };
-  }
-  const genConfig = {};
-  if (config.temperature !== void 0)
-    genConfig.temperature = config.temperature;
-  if (config.maxTokens !== void 0)
-    genConfig.maxOutputTokens = config.maxTokens;
-  if (Object.keys(genConfig).length > 0) body.generationConfig = genConfig;
-  if (tools && tools.length > 0) {
-    body.tools = [
-      {
-        functionDeclarations: tools.map((t) => ({
-          name: t.name,
-          description: t.description,
-          parameters: sanitizeSchemaForGemini(t.inputSchema)
-        }))
-      }
-    ];
-  }
-  return body;
-}
-async function* streamChat2(params) {
-  const { config, signal } = params;
-  const url = `${endpointFor(config.model, "stream")}&key=${encodeURIComponent(
-    config.apiKey
-  )}`;
-  const res = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(buildBody2(params)),
-    signal
-  });
-  if (!res.ok || !res.body) {
-    const text = await res.text().catch(() => "");
-    throw new Error(
-      `Google request failed (${res.status} ${res.statusText}): ${text}`
-    );
-  }
-  let toolCallCounter = 0;
-  for await (const ev of parseSSE(res.body, signal)) {
-    let parsed;
-    try {
-      parsed = JSON.parse(ev.data);
-    } catch {
-      continue;
-    }
-    const parts = parsed?.candidates?.[0]?.content?.parts ?? [];
-    for (const p of parts) {
-      if (typeof p.text === "string" && p.text.length > 0) {
-        yield { type: "text-delta", delta: p.text };
-      } else if (p.functionCall && typeof p.functionCall === "object") {
-        const idx = toolCallCounter++;
-        const id = `call_${idx}_${p.functionCall.name ?? "tool"}`;
-        const name = p.functionCall.name ?? "";
-        const args = p.functionCall.args && typeof p.functionCall.args === "object" ? p.functionCall.args : {};
-        yield {
-          type: "tool-call-start",
-          index: idx,
-          toolCallId: id,
-          toolName: name
-        };
-        const argsJson = JSON.stringify(args);
-        if (argsJson && argsJson !== "{}") {
-          yield {
-            type: "tool-call-args-delta",
-            index: idx,
-            toolCallId: id,
-            toolName: name,
-            argsDelta: argsJson
-          };
-        }
-        yield {
-          type: "tool-call-ready",
-          index: idx,
-          toolCallId: id,
-          toolName: name,
-          args
-        };
-      }
-    }
-  }
-  yield { type: "done" };
-}
-async function chat2(params) {
-  const { config, signal } = params;
-  const url = `${endpointFor(config.model, "single")}?key=${encodeURIComponent(
-    config.apiKey
-  )}`;
-  const res = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(buildBody2(params)),
-    signal
-  });
-  if (!res.ok) {
-    const text2 = await res.text().catch(() => "");
-    throw new Error(
-      `Google request failed (${res.status} ${res.statusText}): ${text2}`
-    );
-  }
-  const json = await res.json();
-  let text = "";
-  const toolCalls = [];
-  const parts = json?.candidates?.[0]?.content?.parts ?? [];
-  for (const p of parts) {
-    if (typeof p.text === "string") text += p.text;
-    else if (p.functionCall) {
-      toolCalls.push({
-        id: `call_${toolCalls.length}_${p.functionCall.name ?? "tool"}`,
-        name: p.functionCall.name ?? "",
-        args: p.functionCall.args && typeof p.functionCall.args === "object" ? p.functionCall.args : {}
-      });
-    }
-  }
-  return { text, toolCalls };
-}
-
-// src/llm/ndjson.ts
-async function* parseNDJSON(body, signal) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      if (signal?.aborted) return;
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        try {
-          yield JSON.parse(trimmed);
-        } catch {
-        }
-      }
-    }
-    const trailing = buffer.trim();
-    if (trailing) {
-      try {
-        yield JSON.parse(trailing);
-      } catch {
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-// src/llm/providers/ollama/utils.ts
-var DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
-function normalizeOllamaBaseUrl(baseUrl) {
-  const raw = (baseUrl || DEFAULT_OLLAMA_BASE_URL).trim();
-  let end = raw.length;
-  while (end > 0 && raw.charCodeAt(end - 1) === 47) {
-    end--;
-  }
-  const trimmed = raw.slice(0, end);
-  return trimmed.endsWith("/api") ? trimmed.slice(0, -4) : trimmed;
-}
-function buildOllamaApiUrl(baseUrl, path) {
-  return `${normalizeOllamaBaseUrl(baseUrl)}${path}`;
-}
-
-// src/llm/providers/ollama/index.ts
-function toOllamaImages(content) {
-  const images = [];
-  for (const part of content) {
-    if (part.type !== "image") continue;
-    if (part.data) {
-      images.push(part.data);
-      continue;
-    }
-    const parsed = parseDataUrl(part.url);
-    if (parsed?.data) {
-      images.push(parsed.data);
-    }
-  }
-  return images;
-}
-function toOllamaContent(content) {
-  if (typeof content === "string") {
-    return { content };
-  }
-  const text = content.filter(
-    (part) => part.type === "text"
-  ).map((part) => part.text).join("");
-  const images = toOllamaImages(content);
-  return {
-    content: text,
-    ...images.length > 0 ? { images } : {}
-  };
-}
-function toOllamaMessages(messages) {
-  return messages.map((message) => {
-    if (message.role === "tool") {
-      return {
-        role: "tool",
-        tool_name: message.toolName,
-        content: typeof message.content === "string" ? message.content : JSON.stringify(message.toolResult ?? message.content)
-      };
-    }
-    if (message.role === "assistant") {
-      const content = typeof message.content === "string" ? { content: message.content } : toOllamaContent(message.content);
-      return {
-        role: "assistant",
-        ...content,
-        ...message.toolCalls?.length ? {
-          tool_calls: message.toolCalls.map((toolCall, index) => ({
-            type: "function",
-            function: {
-              index,
-              name: toolCall.name,
-              arguments: toolCall.args
-            }
-          }))
-        } : {}
-      };
-    }
-    return {
-      role: message.role,
-      ...toOllamaContent(message.content)
-    };
-  });
-}
-function buildBody3(params, stream) {
-  const { config, messages, tools } = params;
-  const body = {
-    model: config.model,
-    messages: toOllamaMessages(messages),
-    stream
-  };
-  const options = {};
-  if (config.temperature !== void 0)
-    options.temperature = config.temperature;
-  if (config.maxTokens !== void 0) options.num_predict = config.maxTokens;
-  if (Object.keys(options).length > 0) body.options = options;
-  if (tools && tools.length > 0) {
-    body.tools = tools.map((tool) => ({
-      type: "function",
-      function: {
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.inputSchema
-      }
-    }));
-  }
-  return body;
-}
-function buildHeaders(config) {
-  return {
-    "Content-Type": "application/json",
-    ...config.apiKey.trim() ? { Authorization: `Bearer ${config.apiKey.trim()}` } : {}
-  };
-}
-function normalizeToolCalls(toolCalls) {
-  if (!Array.isArray(toolCalls)) return [];
-  return toolCalls.map((toolCall) => {
-    const functionCall = toolCall && typeof toolCall === "object" ? toolCall.function : void 0;
-    const name = typeof functionCall?.name === "string" ? functionCall.name : "";
-    const rawArgs = functionCall?.arguments;
-    const args = rawArgs && typeof rawArgs === "object" ? rawArgs : {};
-    return {
-      name,
-      args
-    };
-  }).filter((toolCall) => toolCall.name);
-}
-async function* streamChat3(params) {
-  const { config, signal } = params;
-  const res = await fetch(buildOllamaApiUrl(config.baseUrl, "/api/chat"), {
-    method: "POST",
-    headers: buildHeaders(config),
-    body: JSON.stringify(buildBody3(params, true)),
-    signal
-  });
-  if (!res.ok || !res.body) {
-    const text = await res.text().catch(() => "");
-    throw new Error(
-      `Ollama request failed (${res.status} ${res.statusText}): ${text}`
-    );
-  }
-  let toolCallsEmitted = false;
-  for await (const chunk of parseNDJSON(res.body, signal)) {
-    const message = chunk && typeof chunk === "object" ? chunk.message : void 0;
-    if (typeof message?.content === "string" && message.content.length > 0) {
-      yield { type: "text-delta", delta: message.content };
-    }
-    if (!toolCallsEmitted) {
-      const toolCalls = normalizeToolCalls(message?.tool_calls);
-      if (toolCalls.length > 0) {
-        for (const [index, toolCall] of toolCalls.entries()) {
-          const toolCallId = `call_${index}_${toolCall.name || "tool"}`;
-          yield {
-            type: "tool-call-start",
-            index,
-            toolCallId,
-            toolName: toolCall.name
-          };
-          const argsJson = JSON.stringify(toolCall.args);
-          if (argsJson && argsJson !== "{}") {
-            yield {
-              type: "tool-call-args-delta",
-              index,
-              toolCallId,
-              toolName: toolCall.name,
-              argsDelta: argsJson
-            };
-          }
-          yield {
-            type: "tool-call-ready",
-            index,
-            toolCallId,
-            toolName: toolCall.name,
-            args: toolCall.args
-          };
-        }
-        toolCallsEmitted = true;
-      }
-    }
-    if (chunk && typeof chunk === "object" && chunk.error) {
-      yield {
-        type: "error",
-        message: String(chunk.error)
-      };
-    }
-  }
-  yield { type: "done" };
-}
-async function chat3(params) {
-  const { config, signal } = params;
-  const res = await fetch(buildOllamaApiUrl(config.baseUrl, "/api/chat"), {
-    method: "POST",
-    headers: buildHeaders(config),
-    body: JSON.stringify(buildBody3(params, false)),
-    signal
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new Error(
-      `Ollama request failed (${res.status} ${res.statusText}): ${text}`
-    );
-  }
-  const json = await res.json();
-  const message = json?.message ?? {};
-  return {
-    text: typeof message.content === "string" ? message.content : "",
-    toolCalls: normalizeToolCalls(message.tool_calls).map((tc, index) => ({
-      id: `call_${index}_${tc.name || "tool"}`,
-      name: tc.name,
-      args: tc.args
-    }))
-  };
-}
-
-// src/llm/providers/openai.ts
-var OPENAI_BASE_URL = "https://api.openai.com/v1";
-function buildEndpoint(config, path) {
-  return `${config.baseUrl ?? OPENAI_BASE_URL}${path}`;
-}
-function buildHeaders2(config) {
-  const headers = {
-    "Content-Type": "application/json",
-    ...config.extraHeaders
-  };
-  if (config.apiKey) {
-    headers.Authorization = `Bearer ${config.apiKey}`;
-  }
-  return headers;
-}
-function toOpenAIContent(content) {
-  if (typeof content === "string") return content;
-  return content.map((p) => {
-    if (p.type === "text") return { type: "text", text: p.text };
-    return { type: "image_url", image_url: { url: p.url } };
-  });
-}
-function toOpenAIMessages(messages) {
-  const out = [];
-  for (const m of messages) {
-    if (m.role === "tool") {
-      const { text, imageParts } = partitionToolContent(m.content);
-      const fallback = imageParts.length > 0 ? "[image content; see next message]" : "[no content]";
-      out.push({
-        role: "tool",
-        tool_call_id: m.toolCallId,
-        content: text || fallback
-      });
-      if (imageParts.length > 0) {
-        const userParts = [
-          {
-            type: "text",
-            text: toolImageFollowupHeader(m.toolName, imageParts.length)
-          },
-          ...imageParts.map((p) => ({
-            type: "image_url",
-            image_url: { url: p.url }
-          }))
-        ];
-        out.push({ role: "user", content: userParts });
-      }
-      continue;
-    }
-    if (m.role === "assistant") {
-      const entry = {
-        role: "assistant",
-        content: typeof m.content === "string" && m.content.length > 0 ? m.content : null
-      };
-      if (m.toolCalls?.length) {
-        entry.tool_calls = m.toolCalls.map((tc) => ({
-          id: tc.id,
-          type: "function",
-          function: { name: tc.name, arguments: JSON.stringify(tc.args) }
-        }));
-      }
-      out.push(entry);
-      continue;
-    }
-    out.push({ role: m.role, content: toOpenAIContent(m.content) });
-  }
-  return out;
-}
-async function* streamChat4(params) {
-  const { config, messages, tools, signal } = params;
-  const body = {
-    model: config.model,
-    messages: toOpenAIMessages(messages),
-    stream: true
-  };
-  if (config.temperature !== void 0) body.temperature = config.temperature;
-  if (config.maxTokens !== void 0) body.max_tokens = config.maxTokens;
-  if (tools && tools.length > 0) {
-    body.tools = tools.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.inputSchema
-      }
-    }));
-  }
-  const endpoint = buildEndpoint(config, "/chat/completions");
-  const res = await fetch(endpoint, {
-    method: "POST",
-    headers: buildHeaders2(config),
-    body: JSON.stringify(body),
-    signal
-  });
-  if (!res.ok || !res.body) {
-    const text = await res.text().catch(() => "");
-    throw new Error(
-      `OpenAI request failed (${res.status} ${res.statusText}): ${text}`
-    );
-  }
-  const buffers = /* @__PURE__ */ new Map();
-  for await (const ev of parseSSE(res.body, signal)) {
-    if (!ev.data || ev.data === "[DONE]") continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(ev.data);
-    } catch {
-      continue;
-    }
-    const choice = parsed?.choices?.[0];
-    if (!choice) continue;
-    const delta = choice.delta ?? {};
-    if (typeof delta.content === "string" && delta.content.length > 0) {
-      yield { type: "text-delta", delta: delta.content };
-    }
-    if (Array.isArray(delta.tool_calls)) {
-      for (const tc of delta.tool_calls) {
-        const idx = typeof tc.index === "number" ? tc.index : 0;
-        let buf = buffers.get(idx);
-        if (!buf) {
-          buf = {
-            id: tc.id ?? `call_${idx}`,
-            name: tc.function?.name ?? "",
-            argsJson: "",
-            started: false
-          };
-          buffers.set(idx, buf);
-        }
-        if (tc.id && !buf.id.startsWith("call_")) buf.id = tc.id;
-        else if (tc.id) buf.id = tc.id;
-        if (tc.function?.name) buf.name = tc.function.name;
-        if (!buf.started && buf.name) {
-          buf.started = true;
-          yield {
-            type: "tool-call-start",
-            index: idx,
-            toolCallId: buf.id,
-            toolName: buf.name
-          };
-        }
-        const argsChunk = tc.function?.arguments;
-        if (typeof argsChunk === "string" && argsChunk.length > 0) {
-          buf.argsJson += argsChunk;
-          if (buf.started) {
-            yield {
-              type: "tool-call-args-delta",
-              index: idx,
-              toolCallId: buf.id,
-              toolName: buf.name,
-              argsDelta: argsChunk
-            };
-          }
-        }
-      }
-    }
-    if (choice.finish_reason) {
-      for (const [idx, buf] of buffers) {
-        let args = {};
-        if (buf.argsJson) {
-          try {
-            args = JSON.parse(buf.argsJson);
-          } catch {
-            args = {};
-          }
-        }
-        yield {
-          type: "tool-call-ready",
-          index: idx,
-          toolCallId: buf.id,
-          toolName: buf.name,
-          args
-        };
-      }
-      buffers.clear();
-    }
-  }
-  yield { type: "done" };
-}
-async function chat4(params) {
-  const { config, messages, tools, signal } = params;
-  const body = {
-    model: config.model,
-    messages: toOpenAIMessages(messages)
-  };
-  if (config.temperature !== void 0) body.temperature = config.temperature;
-  if (config.maxTokens !== void 0) body.max_tokens = config.maxTokens;
-  if (tools && tools.length > 0) {
-    body.tools = tools.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.inputSchema
-      }
-    }));
-  }
-  const endpoint = buildEndpoint(config, "/chat/completions");
-  const res = await fetch(endpoint, {
-    method: "POST",
-    headers: buildHeaders2(config),
-    body: JSON.stringify(body),
-    signal
-  });
-  if (!res.ok) {
-    const text2 = await res.text().catch(() => "");
-    throw new Error(
-      `OpenAI request failed (${res.status} ${res.statusText}): ${text2}`
-    );
-  }
-  const json = await res.json();
-  const choice = json?.choices?.[0]?.message;
-  const text = typeof choice?.content === "string" ? choice.content : "";
-  const toolCalls = Array.isArray(choice?.tool_calls) ? choice.tool_calls.map((tc) => {
-    let args = {};
-    try {
-      args = JSON.parse(tc?.function?.arguments ?? "{}");
-    } catch {
-      args = {};
-    }
-    return {
-      id: tc.id,
-      name: tc.function?.name ?? "",
-      args
-    };
-  }) : [];
-  return { text, toolCalls };
-}
-
-// src/llm/providers/index.ts
-function withOpenRouter(params) {
-  return {
-    ...params,
-    config: {
-      ...params.config,
-      baseUrl: "https://openrouter.ai/api/v1",
-      extraHeaders: {
-        "HTTP-Referer": "https://inspector.mcp-use.com",
-        "X-Title": "mcp-use Inspector"
-      }
-    }
-  };
-}
-function streamChat5(params) {
-  switch (params.config.provider) {
-    case "openai":
-    case "openai-compatible":
-      return streamChat4(params);
-    case "anthropic":
-      return streamChat(params);
-    case "google":
-      return streamChat2(params);
-    case "openrouter":
-      return streamChat4(withOpenRouter(params));
-    case "ollama":
-      return streamChat3(params);
-    default:
-      throw new Error(`Unsupported LLM provider: ${params.config.provider}`);
-  }
-}
-function chat5(params) {
-  switch (params.config.provider) {
-    case "openai":
-    case "openai-compatible":
-      return chat4(params);
-    case "anthropic":
-      return chat(params);
-    case "google":
-      return chat2(params);
-    case "openrouter":
-      return chat4(withOpenRouter(params));
-    case "ollama":
-      return chat3(params);
-    default:
-      throw new Error(`Unsupported LLM provider: ${params.config.provider}`);
-  }
-}
-
-// src/llm/toolLoop.ts
-async function* runToolLoop(params) {
-  const { config, tools, callTool, signal } = params;
-  const maxSteps = params.maxSteps ?? 10;
-  const messages = [...params.messages];
-  for (let step = 0; step < maxSteps; step++) {
-    if (signal?.aborted) return;
-    const pendingToolCalls = [];
-    let assistantText = "";
-    try {
-      for await (const ev of streamChat5({
-        config,
-        messages,
-        tools,
-        signal
-      })) {
-        if (ev.type === "text-delta") {
-          assistantText += ev.delta;
-        } else if (ev.type === "tool-call-ready") {
-          pendingToolCalls.push({
-            id: ev.toolCallId,
-            name: ev.toolName,
-            args: ev.args
-          });
-        }
-        yield ev;
-      }
-    } catch (err) {
-      yield {
-        type: "error",
-        message: err instanceof Error ? err.message : String(err)
-      };
-      return;
-    }
-    if (pendingToolCalls.length === 0) {
-      return;
-    }
-    messages.push({
-      role: "assistant",
-      content: assistantText,
-      toolCalls: pendingToolCalls
-    });
-    for (const tc of pendingToolCalls) {
-      if (signal?.aborted) return;
-      let result;
-      let isError = false;
-      try {
-        result = await callTool(tc.name, tc.args);
-        isError = isToolResultError(result);
-      } catch (err) {
-        isError = true;
-        result = {
-          isError: true,
-          error: err instanceof Error ? err.message : String(err)
-        };
-      }
-      messages.push({
-        role: "tool",
-        content: toolResultToContent(result),
-        toolCallId: tc.id,
-        toolName: tc.name,
-        toolResult: result,
-        toolIsError: isError
-      });
-      yield {
-        type: "tool-result",
-        toolCallId: tc.id,
-        toolName: tc.name,
-        result,
-        isError
-      };
-    }
-  }
-}
-async function runToolLoopNonStreaming(params) {
-  const { config, tools, callTool, signal } = params;
-  const maxSteps = params.maxSteps ?? 10;
-  const messages = [...params.messages];
-  const transcriptToolCalls = [];
-  let finalText = "";
-  for (let step = 0; step < maxSteps; step++) {
-    if (signal?.aborted) break;
-    const { text, toolCalls } = await chat5({ config, messages, tools, signal });
-    if (toolCalls.length === 0) {
-      finalText = text;
-      break;
-    }
-    messages.push({
-      role: "assistant",
-      content: text,
-      toolCalls
-    });
-    for (const tc of toolCalls) {
-      let result;
-      let isError = false;
-      try {
-        result = await callTool(tc.name, tc.args);
-        isError = isToolResultError(result);
-      } catch (err) {
-        isError = true;
-        result = {
-          isError: true,
-          error: err instanceof Error ? err.message : String(err)
-        };
-      }
-      transcriptToolCalls.push({
-        toolName: tc.name,
-        args: tc.args,
-        result
-      });
-      messages.push({
-        role: "tool",
-        content: toolResultToContent(result),
-        toolCallId: tc.id,
-        toolName: tc.name,
-        toolResult: result,
-        toolIsError: isError
-      });
-    }
-  }
-  return { content: finalText, toolCalls: transcriptToolCalls };
-}
-
-// src/server/shared-utils.ts
-function toBase64(str) {
-  if (typeof window !== "undefined" && typeof window.btoa === "function") {
-    return window.btoa(str);
-  }
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(str).toString("base64");
-  }
-  throw new Error("No base64 encoding method available");
-}
-async function* handleChatRequestStream(requestBody) {
-  const { mcpServerUrl, llmConfig, authConfig, messages } = requestBody;
-  if (!mcpServerUrl || !llmConfig || !messages) {
-    throw new Error(
-      "Missing required fields: mcpServerUrl, llmConfig, messages"
-    );
-  }
-  const { MCPClient } = await import("mcp-use");
-  const client = new MCPClient();
-  const serverName = `inspector-${Date.now()}`;
-  const serverConfig = {
-    url: mcpServerUrl,
-    preventAutoAuth: true
-  };
-  if (authConfig && authConfig.type !== "none") {
-    serverConfig.headers = {};
-    if (authConfig.type === "basic" && authConfig.username && authConfig.password) {
-      const auth = toBase64(`${authConfig.username}:${authConfig.password}`);
-      serverConfig.headers.Authorization = `Basic ${auth}`;
-    } else if (authConfig.type === "bearer" && authConfig.token) {
-      serverConfig.headers.Authorization = `Bearer ${authConfig.token}`;
-    } else if (authConfig.type === "oauth") {
-      if (authConfig.oauthTokens?.access_token) {
-        const tokenType = authConfig.oauthTokens.token_type ? authConfig.oauthTokens.token_type.charAt(0).toUpperCase() + authConfig.oauthTokens.token_type.slice(1) : "Bearer";
-        serverConfig.headers.Authorization = `${tokenType} ${authConfig.oauthTokens.access_token}`;
-      }
-    }
-  }
-  try {
-    const url = new URL(mcpServerUrl);
-    if (url.username && url.password && (!authConfig || authConfig.type === "none")) {
-      const auth = toBase64(`${url.username}:${url.password}`);
-      serverConfig.headers = serverConfig.headers || {};
-      serverConfig.headers.Authorization = `Basic ${auth}`;
-      serverConfig.url = `${url.protocol}//${url.host}${url.pathname}${url.search}`;
-    }
-  } catch (error) {
-    console.warn("Failed to parse MCP server URL for auth:", error);
-  }
-  client.addServer(serverName, serverConfig);
-  try {
-    await client.createAllSessions();
-    const session = client.getAllActiveSessions()[serverName];
-    if (!session) {
-      throw new Error(`Failed to create MCP session for ${serverName}`);
-    }
-    const mcpTools = session.connector.tools ?? [];
-    const tools = mcpTools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      inputSchema: t.inputSchema ?? {
-        type: "object"
-      }
-    }));
-    const providerMessages = [
-      {
-        role: "system",
-        content: "You are a helpful assistant with access to MCP tools. Help users interact with the MCP server."
-      },
-      ...convertMessagesToProvider(messages)
-    ];
-    const messageId = `msg-${Date.now()}`;
-    yield `data: ${JSON.stringify({ type: "message", id: messageId, role: "assistant" })}
-
-`;
-    const toolCallIdByIndex = /* @__PURE__ */ new Map();
-    for await (const ev of runToolLoop({
-      config: {
-        provider: llmConfig.provider,
-        model: llmConfig.model,
-        apiKey: llmConfig.apiKey,
-        temperature: llmConfig.temperature,
-        baseUrl: llmConfig.baseUrl
-      },
-      messages: providerMessages,
-      tools,
-      callTool: async (name, args) => {
-        return await session.connector.callTool(name, args);
-      },
-      maxSteps: 10
-    })) {
-      if (ev.type === "text-delta") {
-        yield `data: ${JSON.stringify({
-          type: "text",
-          id: messageId,
-          content: ev.delta
-        })}
-
-`;
-      } else if (ev.type === "tool-call-start") {
-        toolCallIdByIndex.set(ev.index, {
-          toolCallId: ev.toolCallId,
-          toolName: ev.toolName,
-          argsBuffer: ""
-        });
-      } else if (ev.type === "tool-call-args-delta") {
-        const rec = toolCallIdByIndex.get(ev.index);
-        if (rec) rec.argsBuffer += ev.argsDelta;
-      } else if (ev.type === "tool-call-ready") {
-        yield `data: ${JSON.stringify({
-          type: "tool-call",
-          id: messageId,
-          toolCallId: ev.toolCallId,
-          toolName: ev.toolName,
-          args: ev.args
-        })}
-
-`;
-      } else if (ev.type === "tool-result") {
-        yield `data: ${JSON.stringify({
-          type: "tool-result",
-          id: messageId,
-          toolCallId: ev.toolCallId,
-          toolName: ev.toolName,
-          result: ev.result
-        })}
-
-`;
-      } else if (ev.type === "error") {
-        yield `data: ${JSON.stringify({
-          type: "error",
-          id: messageId,
-          error: ev.message
-        })}
-
-`;
-      }
-    }
-    yield `data: ${JSON.stringify({ type: "done", id: messageId })}
-
-`;
-  } finally {
-    await client.closeAllSessions();
-  }
-}
-async function handleChatRequest(requestBody) {
-  const { mcpServerUrl, llmConfig, authConfig, messages } = requestBody;
-  if (!mcpServerUrl || !llmConfig || !messages) {
-    throw new Error(
-      "Missing required fields: mcpServerUrl, llmConfig, messages"
-    );
-  }
-  const { MCPClient } = await import("mcp-use");
-  const client = new MCPClient();
-  const serverName = `inspector-${Date.now()}`;
-  const serverConfig = {
-    url: mcpServerUrl,
-    preventAutoAuth: true
-  };
-  if (authConfig && authConfig.type !== "none") {
-    serverConfig.headers = {};
-    if (authConfig.type === "basic" && authConfig.username && authConfig.password) {
-      const auth = toBase64(`${authConfig.username}:${authConfig.password}`);
-      serverConfig.headers.Authorization = `Basic ${auth}`;
-    } else if (authConfig.type === "bearer" && authConfig.token) {
-      serverConfig.headers.Authorization = `Bearer ${authConfig.token}`;
-    } else if (authConfig.type === "oauth") {
-      if (authConfig.oauthTokens?.access_token) {
-        const tokenType = authConfig.oauthTokens.token_type ? authConfig.oauthTokens.token_type.charAt(0).toUpperCase() + authConfig.oauthTokens.token_type.slice(1) : "Bearer";
-        serverConfig.headers.Authorization = `${tokenType} ${authConfig.oauthTokens.access_token}`;
-      }
-    }
-  }
-  try {
-    const url = new URL(mcpServerUrl);
-    if (url.username && url.password && (!authConfig || authConfig.type === "none")) {
-      const auth = toBase64(`${url.username}:${url.password}`);
-      serverConfig.headers = serverConfig.headers || {};
-      serverConfig.headers.Authorization = `Basic ${auth}`;
-      serverConfig.url = `${url.protocol}//${url.host}${url.pathname}${url.search}`;
-    }
-  } catch (error) {
-    console.warn("Failed to parse MCP server URL for auth:", error);
-  }
-  client.addServer(serverName, serverConfig);
-  try {
-    await client.createAllSessions();
-    const session = client.getAllActiveSessions()[serverName];
-    if (!session) {
-      throw new Error(`Failed to create MCP session for ${serverName}`);
-    }
-    const mcpTools = session.connector.tools ?? [];
-    const tools = mcpTools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      inputSchema: t.inputSchema ?? {
-        type: "object"
-      }
-    }));
-    const providerMessages = [
-      {
-        role: "system",
-        content: "You are a helpful assistant with access to MCP tools. Help users interact with the MCP server."
-      },
-      ...convertMessagesToProvider(messages)
-    ];
-    const { content, toolCalls } = await runToolLoopNonStreaming({
-      config: {
-        provider: llmConfig.provider,
-        model: llmConfig.model,
-        apiKey: llmConfig.apiKey,
-        temperature: llmConfig.temperature,
-        baseUrl: llmConfig.baseUrl
-      },
-      messages: providerMessages,
-      tools,
-      callTool: async (name, args) => {
-        return await session.connector.callTool(name, args);
-      },
-      maxSteps: 10
-    });
-    return {
-      content,
-      toolCalls: toolCalls.map((tc) => ({
-        name: tc.toolName,
-        arguments: tc.args,
-        result: tc.result
-      }))
-    };
-  } finally {
-    await client.closeAllSessions();
-  }
-}
-var widgetDataStore = /* @__PURE__ */ new Map();
-setInterval(
-  () => {
-    const now = Date.now();
-    const ONE_HOUR = 60 * 60 * 1e3;
-    for (const [toolId, data] of widgetDataStore.entries()) {
-      if (now - data.timestamp > ONE_HOUR) {
-        widgetDataStore.delete(toolId);
-      }
-    }
-  },
-  5 * 60 * 1e3
-).unref();
-function storeWidgetData(data) {
-  const {
-    serverId,
-    uri,
-    toolInput,
-    toolOutput,
-    toolResponseMetadata,
-    resourceData,
-    toolId,
-    widgetCSP,
-    mcpAppsCsp,
-    mcpAppsPermissions,
-    devWidgetUrl,
-    devServerBaseUrl,
-    theme
-  } = data;
-  const debugWidget = process.env.DEBUG != null && process.env.DEBUG !== "" && process.env.DEBUG !== "0" && process.env.DEBUG.toLowerCase() !== "false";
-  if (debugWidget) {
-    console.log("[Widget Store] Received request for toolId:", toolId);
-    console.log("[Widget Store] Fields:", {
-      serverId,
-      uri,
-      hasResourceData: !!resourceData,
-      hasToolInput: !!toolInput,
-      hasToolOutput: !!toolOutput,
-      hasToolResponseMetadata: !!toolResponseMetadata,
-      toolResponseMetadata,
-      hasWidgetCSP: !!widgetCSP,
-      devWidgetUrl,
-      devServerBaseUrl
-    });
-  }
-  if (!serverId || !uri || !toolId || !resourceData) {
-    const missingFields = [];
-    if (!serverId) missingFields.push("serverId");
-    if (!uri) missingFields.push("uri");
-    if (!toolId) missingFields.push("toolId");
-    if (!resourceData) missingFields.push("resourceData");
-    console.error("[Widget Store] Missing required fields:", missingFields);
-    return {
-      success: false,
-      error: `Missing required fields: ${missingFields.join(", ")}`
-    };
-  }
-  widgetDataStore.set(toolId, {
-    serverId,
-    uri,
-    toolInput,
-    toolOutput,
-    toolResponseMetadata,
-    resourceData,
-    toolId,
-    timestamp: Date.now(),
-    widgetCSP,
-    mcpAppsCsp,
-    mcpAppsPermissions,
-    devWidgetUrl,
-    devServerBaseUrl,
-    theme
-  });
-  if (debugWidget) {
-    console.log("[Widget Store] Data stored successfully for toolId:", toolId);
-  }
-  return { success: true };
-}
-function getWidgetData(toolId) {
-  return widgetDataStore.get(toolId);
-}
-function generateWidgetContainerHtml(basePath, toolId) {
-  return `
-    <!DOCTYPE html>
-    <html>
-    <head>
-      <meta charset="utf-8">
-      <title>Loading Widget...</title>
-    </head>
-    <body>
-      <script>
-        (async function() {
-          try {
-            // Fetch the actual widget HTML using toolId
-            const response = await fetch('${basePath}/api/resources/widget-content/${toolId}');
-            const html = await response.text();
-
-            // Replace entire document with widget HTML using proper method
-            document.open();
-            document.write(html);
-            document.close();
-          } catch (error) {
-            console.error('Failed to load widget:', error);
-            document.body.innerHTML = '<div style="padding: 20px; color: red;">Failed to load widget: ' + error.message + '</div>';
-          }
-        })();
-      </script>
-    </body>
-    </html>
-  `;
-}
-function generateWidgetContentHtml(widgetData) {
-  const {
-    serverId,
-    uri,
-    toolInput,
-    toolOutput,
-    toolResponseMetadata,
-    resourceData,
-    toolId,
-    theme,
-    playground
-  } = widgetData;
-  const debugWidget = process.env.DEBUG != null && process.env.DEBUG !== "" && process.env.DEBUG !== "0" && process.env.DEBUG.toLowerCase() !== "false";
-  if (debugWidget) {
-    console.log("[Widget Content] Using pre-fetched resource for:", {
-      serverId,
-      uri
-    });
-  }
-  let htmlContent = "";
-  const contentsArray = Array.isArray(resourceData?.contents) ? resourceData.contents : [];
-  const firstContent = contentsArray[0];
-  if (firstContent) {
-    if (typeof firstContent.text === "string") {
-      htmlContent = firstContent.text;
-    } else if (typeof firstContent.blob === "string") {
-      htmlContent = firstContent.blob;
-    }
-  }
-  if (!htmlContent && resourceData && typeof resourceData === "object") {
-    const recordContent = resourceData;
-    if (typeof recordContent.text === "string") {
-      htmlContent = recordContent.text;
-    } else if (typeof recordContent.blob === "string") {
-      htmlContent = recordContent.blob;
-    }
-  }
-  if (!htmlContent) {
-    return { html: "", error: "No HTML content found" };
-  }
-  const widgetStateKey = `openai-widget-state:${toolId}`;
-  const safeToolInput = JSON.stringify(toolInput ?? null).replace(/</g, "\\u003c").replace(/>/g, "\\u003e");
-  const safeToolOutput = JSON.stringify(toolOutput ?? null).replace(/</g, "\\u003c").replace(/>/g, "\\u003e");
-  const safeToolResponseMetadata = JSON.stringify(toolResponseMetadata ?? null).replace(/</g, "\\u003c").replace(/>/g, "\\u003e");
-  const safeToolId = JSON.stringify(toolId);
-  const safeWidgetStateKey = JSON.stringify(widgetStateKey);
-  const safeTheme = JSON.stringify(theme === "dark" ? "dark" : "light");
-  const locale = playground?.locale || "en-US";
-  const deviceType = playground?.deviceType || "desktop";
-  const capabilities = playground?.capabilities || {
-    hover: true,
-    touch: false
-  };
-  const safeAreaInsets = playground?.safeAreaInsets || {
-    top: 0,
-    right: 0,
-    bottom: 0,
-    left: 0
-  };
-  const safeLocale = JSON.stringify(locale);
-  const safeUserAgent = JSON.stringify({
-    device: { type: deviceType },
-    capabilities
-  });
-  const safeSafeArea = JSON.stringify({ insets: safeAreaInsets });
-  const apiScript = `
-    <script>
-      (function() {
-        'use strict';
-
-        // Change URL to "/" for React Router compatibility.
-        // Skip when loaded inside the inspector (widget-content endpoint)
-        // to prevent Vite HMR reloads from navigating to "/" (inspector SPA).
-        if (window.location.pathname !== '/' && !window.location.pathname.includes('/inspector/')) {
-          history.replaceState(null, '', '/');
-        }
-
-        function emitWidgetRuntimeError(payload) {
-          var args = [{
-            message: payload && payload.message ? payload.message : "Unknown widget runtime error",
-            stack: payload && payload.stack ? payload.stack : undefined,
-            source: payload && payload.source ? payload.source : undefined,
-            fileName: payload && payload.fileName ? payload.fileName : undefined,
-            line: payload && payload.line ? payload.line : undefined,
-            column: payload && payload.column ? payload.column : undefined,
-            timestamp: payload && payload.timestamp ? payload.timestamp : Date.now(),
-          }];
-          try {
-            window.parent.postMessage(
-              {
-                type: "iframe-console-log",
-                level: "error",
-                args: args,
-                timestamp: new Date().toISOString(),
-                url: window.location.href,
-                toolId: ${safeToolId},
-              },
-              "*"
-            );
-          } catch (emitErr) {}
-        }
-
-        window.addEventListener("error", function(event) {
-          var err = event && event.error;
-          var message =
-            (err && err.message) ||
-            (event && event.message) ||
-            "Unknown widget runtime error";
-          emitWidgetRuntimeError({
-            source: "window.error",
-            message: String(message),
-            stack: err && err.stack ? String(err.stack) : undefined,
-            fileName: event && event.filename ? String(event.filename) : undefined,
-            line: event && typeof event.lineno === "number" ? event.lineno : undefined,
-            column: event && typeof event.colno === "number" ? event.colno : undefined,
-            timestamp: Date.now(),
-          });
-        });
-
-        window.addEventListener("unhandledrejection", function(event) {
-          var reason = event ? event.reason : undefined;
-          var message = "Unhandled promise rejection";
-          var stack = undefined;
-          if (reason && typeof reason === "object") {
-            message = String(reason.message || message);
-            stack = reason.stack ? String(reason.stack) : undefined;
-          } else if (typeof reason === "string") {
-            message = reason;
-          } else if (reason != null) {
-            message = String(reason);
-          }
-          emitWidgetRuntimeError({
-            source: "window.unhandledrejection",
-            message: message,
-            stack: stack,
-            timestamp: Date.now(),
-          });
-        });
-
-        const openaiAPI = {
-          toolInput: ${safeToolInput},
-          toolOutput: ${safeToolOutput},
-          toolResponseMetadata: ${safeToolResponseMetadata},
-          displayMode: 'inline',
-          maxHeight: 600,
-          theme: ${safeTheme},
-          locale: ${safeLocale},
-          safeArea: ${safeSafeArea},
-          userAgent: ${safeUserAgent},
-          widgetState: null,
-
-          async setWidgetState(state) {
-            this.widgetState = state;
-            try {
-              localStorage.setItem(${safeWidgetStateKey}, JSON.stringify(state));
-            } catch (err) {
-              console.error('[OpenAI Widget] Failed to save widget state:', err);
-            }
-            window.parent.postMessage({
-              type: 'openai:setWidgetState',
-              toolId: ${safeToolId},
-              state
-            }, '*');
-          },
-
-          async callTool(toolName, params = {}) {
-            return new Promise((resolve, reject) => {
-              const requestId = \`tool_\${Date.now()}_\${Math.random()}\`;
-              const handler = (event) => {
-                if (event.data.type === 'openai:callTool:response' &&
-                    event.data.requestId === requestId) {
-                  window.removeEventListener('message', handler);
-                  if (event.data.error) {
-                    reject(new Error(event.data.error));
-                  } else {
-                    resolve(event.data.result);
-                  }
-                }
-              };
-              window.addEventListener('message', handler);
-              window.parent.postMessage({
-                type: 'openai:callTool',
-                requestId,
-                toolName,
-                params
-              }, '*');
-              setTimeout(() => {
-                window.removeEventListener('message', handler);
-                reject(new Error('Tool call timeout'));
-              }, 30000);
-            });
-          },
-
-          async sendFollowupTurn(message) {
-            const payload = typeof message === 'string'
-              ? { prompt: message }
-              : message;
-            window.parent.postMessage({
-              type: 'openai:sendFollowup',
-              message: payload.prompt || payload
-            }, '*');
-          },
-
-          async requestDisplayMode(options = {}) {
-            const mode = options.mode || 'inline';
-            this.displayMode = mode;
-            window.parent.postMessage({
-              type: 'openai:requestDisplayMode',
-              mode
-            }, '*');
-            return { mode };
-          },
-
-          async sendFollowUpMessage(args) {
-            const prompt = typeof args === 'string' ? args : (args?.prompt || '');
-            return this.sendFollowupTurn(prompt);
-          },
-
-          async notifyIntrinsicHeight(height) {
-            console.log('[OpenAI Widget] notifyIntrinsicHeight called with:', height);
-            if (typeof height !== 'number' || height < 0) {
-              console.error('[OpenAI Widget] Invalid height value:', height);
-              throw new Error('Height must be a non-negative number');
-            }
-            const message = {
-              type: 'openai:notifyIntrinsicHeight',
-              height
-            };
-            console.log('[OpenAI Widget] Sending postMessage to parent:', message);
-            window.parent.postMessage(message, '*');
-          },
-
-          openExternal(payload) {
-            const href = typeof payload === 'string' ? payload : payload?.href;
-            if (href) {
-              window.open(href, '_blank', 'noopener,noreferrer');
-            }
-          }
-        };
-
-        // Report CSP violations to the inspector host
-        document.addEventListener('securitypolicyviolation', function(e) {
-          window.parent.postMessage({
-            type: 'openai:csp-violation',
-            toolId: ${safeToolId},
-            directive: e.violatedDirective,
-            effectiveDirective: e.effectiveDirective,
-            blockedUri: e.blockedURI,
-            sourceFile: e.sourceFile || null,
-            lineNumber: e.lineNumber,
-            columnNumber: e.columnNumber,
-            originalPolicy: e.originalPolicy,
-            disposition: e.disposition,
-            timestamp: Date.now(),
-          }, '*');
-        });
-
-        Object.defineProperty(window, 'openai', {
-          value: openaiAPI,
-          writable: false,
-          configurable: false,
-          enumerable: true
-        });
-
-        Object.defineProperty(window, 'webplus', {
-          value: openaiAPI,
-          writable: false,
-          configurable: false,
-          enumerable: true
-        });
-
-        // Do not fire openai:set_globals here \u2014 window.openai is already set synchronously.
-        // useSyncExternalStore reads it on first render. Firing the event would cause a
-        // redundant second render (double flash at pending/final state).
-
-        // Listen for widget state requests from inspector
-        window.addEventListener('message', (event) => {
-          if (event.data?.type === 'mcp-inspector:getWidgetState') {
-            window.parent.postMessage({
-              type: 'mcp-inspector:widgetStateResponse',
-              toolId: event.data.toolId,
-              state: openaiAPI.widgetState
-            }, '*');
-            return;
-          }
-        });
-
-        // Listen for globals changes from parent (for displayMode, theme, etc.)
-        window.addEventListener('message', (event) => {
-          // Handle new general globalsChanged message
-          if (event.data?.type === 'openai:globalsChanged') {
-            const updates = event.data.updates || {};
-            let hasChanges = false;
-
-            // Update displayMode
-            if (updates.displayMode && ['inline', 'pip', 'fullscreen'].includes(updates.displayMode)) {
-              openaiAPI.displayMode = updates.displayMode;
-              hasChanges = true;
-            }
-
-            // Update theme
-            if (updates.theme && ['light', 'dark'].includes(updates.theme)) {
-              openaiAPI.theme = updates.theme;
-              hasChanges = true;
-            }
-
-            // Update maxHeight
-            if (updates.maxHeight !== undefined && typeof updates.maxHeight === 'number') {
-              openaiAPI.maxHeight = updates.maxHeight;
-              hasChanges = true;
-            }
-
-            // Update locale
-            if (updates.locale && typeof updates.locale === 'string') {
-              openaiAPI.locale = updates.locale;
-              hasChanges = true;
-            }
-
-            // Update safeArea
-            if (updates.safeArea && typeof updates.safeArea === 'object') {
-              openaiAPI.safeArea = updates.safeArea;
-              hasChanges = true;
-            }
-
-            // Update userAgent
-            if (updates.userAgent !== undefined) {
-              openaiAPI.userAgent = updates.userAgent;
-              hasChanges = true;
-            }
-
-            // Dispatch set_globals event to notify React components if any changes occurred
-            if (hasChanges) {
-              try {
-                const globalsEvent = new CustomEvent('openai:set_globals', {
-                  detail: {
-                    globals: {
-                      toolInput: openaiAPI.toolInput,
-                      toolOutput: openaiAPI.toolOutput,
-                      toolResponseMetadata: openaiAPI.toolResponseMetadata || null,
-                      widgetState: openaiAPI.widgetState,
-                      displayMode: openaiAPI.displayMode,
-                      maxHeight: openaiAPI.maxHeight,
-                      theme: openaiAPI.theme,
-                      locale: openaiAPI.locale,
-                      safeArea: openaiAPI.safeArea,
-                      userAgent: openaiAPI.userAgent
-                    }
-                  }
-                });
-                window.dispatchEvent(globalsEvent);
-              } catch (err) {}
-            }
-          }
-          // Handle legacy displayModeChanged message for backward compatibility
-          else if (event.data?.type === 'openai:displayModeChanged') {
-            const newMode = event.data.mode;
-            if (newMode && ['inline', 'pip', 'fullscreen'].includes(newMode)) {
-              openaiAPI.displayMode = newMode;
-              // Dispatch set_globals event to notify React components
-              try {
-                const globalsEvent = new CustomEvent('openai:set_globals', {
-                  detail: {
-                    globals: {
-                      toolInput: openaiAPI.toolInput,
-                      toolOutput: openaiAPI.toolOutput,
-                      toolResponseMetadata: openaiAPI.toolResponseMetadata || null,
-                      widgetState: openaiAPI.widgetState,
-                      displayMode: newMode,
-                      maxHeight: openaiAPI.maxHeight,
-                      theme: openaiAPI.theme,
-                      locale: openaiAPI.locale,
-                      safeArea: openaiAPI.safeArea,
-                      userAgent: openaiAPI.userAgent
-                    }
-                  }
-                });
-                window.dispatchEvent(globalsEvent);
-              } catch (err) {}
-            }
-          }
-        });
-
-        setTimeout(() => {
-          try {
-            const stored = localStorage.getItem(${safeWidgetStateKey});
-            if (stored && window.openai) {
-              window.openai.widgetState = JSON.parse(stored);
-            }
-          } catch (err) {}
-        }, 0);
-      })();
-    </script>
-  `;
-  let modifiedHtml;
-  if (htmlContent.includes("<html") && htmlContent.includes("<head")) {
-    modifiedHtml = htmlContent.replace("<head>", `<head>${apiScript}`);
-  } else {
-    modifiedHtml = `<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  ${apiScript}
-  <title>Widget</title>
-</head>
-<body>
-  ${htmlContent}
-</body>
-</html>`;
-  }
-  if (debugWidget) {
-    console.log("[Widget Content] Generated HTML length:", modifiedHtml.length);
-  }
-  return { html: modifiedHtml };
-}
-function transformMcpAppsCspToSnakeCase(mcpAppsCsp) {
-  if (!mcpAppsCsp) return void 0;
-  const result = {};
-  if (mcpAppsCsp.connectDomains) {
-    result.connect_domains = mcpAppsCsp.connectDomains;
-  }
-  if (mcpAppsCsp.resourceDomains) {
-    result.resource_domains = mcpAppsCsp.resourceDomains;
-  }
-  if (mcpAppsCsp.frameDomains) {
-    result.frame_domains = mcpAppsCsp.frameDomains;
-  }
-  return Object.keys(result).length > 0 ? result : void 0;
-}
-function getWidgetSecurityHeaders(widgetCSP, devServerBaseUrl, frameAncestors) {
-  const trustedCdns = [
-    "https://persistent.oaistatic.com",
-    "https://*.oaistatic.com",
-    "https://unpkg.com",
-    "https://cdn.jsdelivr.net",
-    "https://cdnjs.cloudflare.com",
-    "https://cdn.skypack.dev",
-    "https://*.openai.com"
-  ];
-  const prodResourceDomains = [...trustedCdns];
-  if (widgetCSP?.resource_domains) {
-    prodResourceDomains.push(...widgetCSP.resource_domains);
-  }
-  const prodResourceDomainsStr = prodResourceDomains.join(" ");
-  let devServerOrigin = null;
-  const allResourceDomains = [...prodResourceDomains];
-  if (devServerBaseUrl) {
-    try {
-      devServerOrigin = new URL(devServerBaseUrl).origin;
-      allResourceDomains.push(devServerOrigin);
-    } catch (e) {
-      console.warn(`[CSP] Invalid devServerBaseUrl: ${devServerBaseUrl}`);
-    }
-  }
-  const resourceDomainsStr = allResourceDomains.join(" ");
-  let imgSrc = "'self' data: https: blob:";
-  if (devServerOrigin) {
-    imgSrc = `'self' data: https: blob: ${devServerOrigin}`;
-  }
-  let mediaSrc = "'self' data: https: blob:";
-  if (devServerOrigin) {
-    mediaSrc = `'self' data: https: blob: ${devServerOrigin}`;
-  }
-  let fontSrc = `'self' data: ${resourceDomainsStr}`;
-  if (devServerOrigin) {
-    fontSrc = `'self' data: https: http: ${resourceDomainsStr}`;
-  }
-  let connectSrc = "'self' https: wss: ws:";
-  if (widgetCSP?.connect_domains && widgetCSP.connect_domains.length > 0) {
-    connectSrc = `'self' ${widgetCSP.connect_domains.join(" ")} https: wss: ws:`;
-  }
-  let frameSrc = "'self' blob:";
-  const frameDomains = widgetCSP?.frame_domains || widgetCSP?.resource_domains;
-  if (frameDomains && frameDomains.length > 0) {
-    frameSrc = `'self' blob: ${frameDomains.join(" ")}`;
-  }
-  let frameAncestorsPolicy = "*";
-  if (frameAncestors) {
-    frameAncestorsPolicy = `'self' ${frameAncestors}`.trim();
-  }
-  const headers = {
-    "Content-Security-Policy": [
-      "default-src 'self'",
-      `script-src 'self' 'unsafe-inline' 'unsafe-eval' ${resourceDomainsStr}`,
-      "worker-src 'self' blob:",
-      `child-src 'self' blob: ${frameDomains?.join(" ") || ""}`.trim(),
-      `frame-src ${frameSrc}`,
-      `style-src 'self' 'unsafe-inline' ${resourceDomainsStr}`,
-      `img-src ${imgSrc}`,
-      `media-src ${mediaSrc}`,
-      `font-src ${fontSrc}`,
-      `connect-src ${connectSrc}`,
-      `frame-ancestors ${frameAncestorsPolicy}`
-    ].join("; "),
-    "X-Frame-Options": "SAMEORIGIN",
-    "X-Content-Type-Options": "nosniff",
-    "Cache-Control": "no-cache, no-store, must-revalidate",
-    Pragma: "no-cache",
-    Expires: "0"
-  };
-  if (devServerOrigin) {
-    const prodConnectSrc = "'self' https: wss: ws:";
-    let prodFrameSrc = "'self' blob:";
-    const prodFrameDomains = widgetCSP?.frame_domains || widgetCSP?.resource_domains;
-    if (prodFrameDomains && prodFrameDomains.length > 0) {
-      prodFrameSrc = `'self' blob: ${prodFrameDomains.join(" ")}`;
-    }
-    headers["Content-Security-Policy-Report-Only"] = [
-      "default-src 'self'",
-      `script-src 'self' 'unsafe-inline' 'unsafe-eval' ${prodResourceDomainsStr}`,
-      "worker-src 'self' blob:",
-      `child-src 'self' blob: ${prodFrameDomains?.join(" ") || ""}`.trim(),
-      `frame-src ${prodFrameSrc}`,
-      `style-src 'self' 'unsafe-inline' ${prodResourceDomainsStr}`,
-      "img-src 'self' data: https: blob:",
-      "media-src 'self' data: https: blob:",
-      `font-src 'self' data: ${prodResourceDomainsStr}`,
-      `connect-src ${prodConnectSrc}`,
-      `frame-ancestors ${frameAncestorsPolicy}`
-    ].join("; ");
-  }
-  return headers;
-}
-
-export {
-  handleChatRequestStream,
-  handleChatRequest,
-  storeWidgetData,
-  getWidgetData,
-  generateWidgetContainerHtml,
-  generateWidgetContentHtml,
-  transformMcpAppsCspToSnakeCase,
-  getWidgetSecurityHeaders
-};