@mcpjam/inspector 0.9.21 → 0.9.25

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 Hono10 } from "hono";
+import { Hono as Hono11 } 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 Hono9 } from "hono";
+import { Hono as Hono10 } from "hono";
 
 // routes/mcp/connect.ts
 import { Hono } from "hono";
@@ -186,242 +186,204 @@ var servers_default = servers;
 // routes/mcp/tools.ts
 import { Hono as Hono3 } from "hono";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { TextEncoder as TextEncoder2 } from "util";
 var tools = new Hono3();
-var pendingElicitations = /* @__PURE__ */ new Map();
-tools.post("/", async (c) => {
-  let action;
-  let toolName;
+var activeExecution = null;
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function takeNextElicitation(state) {
+  if (state.queue.length > 0) {
+    return Promise.resolve(state.queue.shift());
+  }
+  return new Promise((resolve) => {
+    state.waiters.push(resolve);
+  });
+}
+tools.post("/list", async (c) => {
   try {
-    const requestData = await c.req.json();
-    action = requestData.action;
-    toolName = requestData.toolName;
-    const { serverConfig, parameters, requestId, response } = requestData;
-    if (!action || !["list", "execute", "respond"].includes(action)) {
-      return c.json(
-        {
-          success: false,
-          error: "Action must be 'list', 'execute', or 'respond'"
-        },
-        400
-      );
+    const { serverId } = await c.req.json();
+    if (!serverId) {
+      return c.json({ error: "serverId is required" }, 400);
     }
-    if (action === "respond") {
-      if (!requestId) {
-        return c.json(
-          {
-            success: false,
-            error: "requestId is required for respond action"
-          },
-          400
-        );
-      }
-      const mcpJamClientManager2 = c.mcpJamClientManager;
-      const success = mcpJamClientManager2.respondToElicitation(
-        requestId,
-        response
-      );
-      if (!success) {
-        const pending = pendingElicitations.get(requestId);
-        if (pending) {
-          pending.resolve(response);
-          pendingElicitations.delete(requestId);
-          return c.json({ success: true });
-        }
-        return c.json(
-          {
-            success: false,
-            error: "No pending elicitation found for this requestId"
-          },
-          404
-        );
+    const mcp2 = c.mcpJamClientManager;
+    const status = mcp2.getConnectionStatus(serverId);
+    if (status !== "connected") {
+      return c.json({ error: `Server '${serverId}' is not connected` }, 400);
+    }
+    const flattenedTools = await mcp2.getToolsetsForServer(serverId);
+    const toolsWithJsonSchema = {};
+    for (const [name17, tool] of Object.entries(flattenedTools)) {
+      let inputSchema = tool.inputSchema;
+      try {
+        inputSchema = zodToJsonSchema(inputSchema);
+      } catch {
       }
-      return c.json({ success: true });
+      toolsWithJsonSchema[name17] = {
+        name: name17,
+        description: tool.description,
+        inputSchema,
+        outputSchema: tool.outputSchema
+      };
     }
-    const encoder = new TextEncoder2();
-    const readableStream = new ReadableStream({
-      async start(controller) {
-        try {
-          if (!serverConfig) {
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({ type: "tool_error", error: "serverConfig is required" })}
-
-`
-              )
-            );
-            controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-            controller.close();
-            return;
-          }
-          const mcpJamClientManager2 = c.mcpJamClientManager;
-          const serverId = serverConfig.name || serverConfig.id || "server";
-          await mcpJamClientManager2.connectToServer(serverId, serverConfig);
-          mcpJamClientManager2.setElicitationCallback(async (request) => {
-            const { requestId: requestId2, message, schema } = request;
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "elicitation_request",
-                  requestId: requestId2,
-                  message,
-                  schema,
-                  toolName: toolName || "unknown",
-                  timestamp: /* @__PURE__ */ new Date()
-                })}
-
-`
-              )
-            );
-            return new Promise((resolve, reject) => {
-              pendingElicitations.set(requestId2, {
-                resolve: (response2) => {
-                  resolve(response2);
-                  pendingElicitations.delete(requestId2);
-                },
-                reject: (error) => {
-                  reject(error);
-                  pendingElicitations.delete(requestId2);
-                }
-              });
-              setTimeout(() => {
-                if (pendingElicitations.has(requestId2)) {
-                  pendingElicitations.delete(requestId2);
-                  reject(new Error("Elicitation timeout"));
-                }
-              }, 3e5);
-            });
-          });
-          if (action === "list") {
-            try {
-              const flattenedTools = await mcpJamClientManager2.getToolsetsForServer(serverId);
-              const toolsWithJsonSchema = {};
-              for (const [name, tool] of Object.entries(flattenedTools)) {
-                let inputSchema = tool.inputSchema;
-                try {
-                  inputSchema = zodToJsonSchema(inputSchema);
-                } catch {
-                }
-                toolsWithJsonSchema[name] = {
-                  name,
-                  description: tool.description,
-                  inputSchema,
-                  outputSchema: tool.outputSchema
-                };
-              }
-              controller.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({ type: "tools_list", tools: toolsWithJsonSchema })}
-
-`
-                )
-              );
-              controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-              controller.close();
-              return;
-            } catch (err) {
-              controller.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({ type: "tool_error", error: err instanceof Error ? err.message : String(err) })}
-
-`
-                )
-              );
-              controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-              controller.close();
-              return;
-            }
-          }
-          if (action === "execute") {
-            if (!toolName) {
-              controller.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({ type: "tool_error", error: "Tool name is required for execution" })}
-
-`
-                )
-              );
-              controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-              controller.close();
-              return;
-            }
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({ type: "tool_executing", toolName, parameters: parameters || {}, message: "Executing tool..." })}
-
-`
-              )
-            );
-            const exec = await mcpJamClientManager2.executeToolDirect(
-              toolName,
-              parameters || {}
-            );
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({ type: "tool_result", toolName, result: exec.result })}
-
-`
-              )
-            );
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({ type: "elicitation_complete", toolName })}
-
-`
-              )
-            );
-            controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-            controller.close();
-            return;
-          }
-        } catch (err) {
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({ type: "tool_error", error: err instanceof Error ? err.message : String(err) })}
-
-`
-            )
-          );
-          controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-          controller.close();
-        } finally {
-          const mcpJamClientManager2 = c.mcpJamClientManager;
-          if (mcpJamClientManager2) {
-            mcpJamClientManager2.clearElicitationCallback();
-          }
-        }
+    return c.json({ tools: toolsWithJsonSchema });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return c.json({ error: msg }, 500);
+  }
+});
+tools.post("/execute", async (c) => {
+  try {
+    const { serverId, toolName, parameters } = await c.req.json();
+    if (!serverId) return c.json({ error: "serverId is required" }, 400);
+    if (!toolName) return c.json({ error: "toolName is required" }, 400);
+    if (activeExecution) {
+      return c.json({ error: "Another execution is already in progress" }, 409);
+    }
+    const mcp2 = c.mcpJamClientManager;
+    const status = mcp2.getConnectionStatus(serverId);
+    if (status !== "connected") {
+      return c.json({ error: `Server '${serverId}' is not connected` }, 400);
+    }
+    const executionId = `exec_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const state = {
+      id: executionId,
+      serverId,
+      toolName,
+      execPromise: Promise.resolve().then(
+        () => mcp2.executeToolDirect(toolName, parameters || {})
+      ),
+      completed: false,
+      queue: [],
+      waiters: []
+    };
+    activeExecution = state;
+    mcp2.setElicitationCallback(async ({ requestId, message, schema }) => {
+      if (!activeExecution) {
+        throw new Error("No active execution");
       }
-    });
-    return new Response(readableStream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
+      const event = {
+        requestId,
+        message,
+        schema,
+        toolName,
+        timestamp: nowIso()
+      };
+      if (activeExecution.waiters.length > 0) {
+        const waiter = activeExecution.waiters.shift();
+        waiter(event);
+      } else {
+        activeExecution.queue.push(event);
       }
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(
+          () => reject(new Error("Elicitation timeout")),
+          3e5
+        );
+        mcp2.getPendingElicitations().set(requestId, {
+          resolve: (response) => {
+            clearTimeout(timeout);
+            resolve(response);
+          },
+          reject: (error) => {
+            clearTimeout(timeout);
+            reject(error);
+          }
+        });
+      });
     });
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : "Unknown error";
+    const race = await Promise.race([
+      state.execPromise.then((res) => ({ kind: "done", res })),
+      takeNextElicitation(state).then(
+        (ev) => ({ kind: "elicit", ev })
+      )
+    ]);
+    if (race.kind === "done") {
+      state.completed = true;
+      state.result = race.res;
+      activeExecution = null;
+      mcp2.clearElicitationCallback();
+      return c.json(
+        { status: "completed", toolName, result: race.res.result },
+        200
+      );
+    }
     return c.json(
       {
-        success: false,
-        error: errorMsg
+        status: "elicitation_required",
+        executionId,
+        requestId: race.ev.requestId,
+        toolName,
+        message: race.ev.message,
+        schema: race.ev.schema,
+        timestamp: race.ev.timestamp
       },
-      500
+      202
     );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return c.json({ error: msg }, 500);
+  }
+});
+tools.post("/respond", async (c) => {
+  try {
+    const { requestId, response } = await c.req.json();
+    if (!requestId) return c.json({ error: "requestId is required" }, 400);
+    if (!activeExecution) return c.json({ error: "No active execution" }, 404);
+    const mcp2 = c.mcpJamClientManager;
+    const ok = mcp2.respondToElicitation(requestId, response);
+    if (!ok)
+      return c.json({ error: "No pending elicitation for requestId" }, 404);
+    const state = activeExecution;
+    try {
+      const race = await Promise.race([
+        state.execPromise.then((res) => ({ kind: "done", res })),
+        takeNextElicitation(state).then(
+          (ev) => ({ kind: "elicit", ev })
+        )
+      ]);
+      if (race.kind === "done") {
+        state.completed = true;
+        state.result = race.res;
+        activeExecution = null;
+        mcp2.clearElicitationCallback();
+        return c.json(
+          {
+            status: "completed",
+            toolName: state.toolName,
+            result: race.res.result
+          },
+          200
+        );
+      }
+      return c.json(
+        {
+          status: "elicitation_required",
+          executionId: state.id,
+          requestId: race.ev.requestId,
+          toolName: state.toolName,
+          message: race.ev.message,
+          schema: race.ev.schema,
+          timestamp: race.ev.timestamp
+        },
+        202
+      );
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return c.json({ error: msg }, 500);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return c.json({ error: msg }, 500);
   }
 });
+tools.post("/", async () => {
+  return new Response(
+    JSON.stringify({
+      error: "Endpoint migrated. Use /list, /execute, or /respond."
+    }),
+    { status: 410, headers: { "Content-Type": "application/json" } }
+  );
+});
 var tools_default = tools;
 
 // routes/mcp/resources.ts
@@ -503,11 +465,11 @@ prompts.post("/list", async (c) => {
 });
 prompts.post("/get", async (c) => {
   try {
-    const { serverId, name, args } = await c.req.json();
+    const { serverId, name: name17, args } = await c.req.json();
     if (!serverId) {
       return c.json({ success: false, error: "serverId is required" }, 400);
     }
-    if (!name) {
+    if (!name17) {
       return c.json(
         {
           success: false,
@@ -518,7 +480,7 @@ prompts.post("/get", async (c) => {
     }
     const mcpJamClientManager2 = c.mcpJamClientManager;
     const content = await mcpJamClientManager2.getPrompt(
-      name,
+      name17,
       serverId,
       args || {}
     );
@@ -539,11 +501,7 @@ var prompts_default = prompts;
 // routes/mcp/chat.ts
 import { Hono as Hono6 } from "hono";
 import { Agent } from "@mastra/core/agent";
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { createOllama } from "ollama-ai-provider";
-import { TextEncoder as TextEncoder3 } from "util";
+import { TextEncoder as TextEncoder2 } from "util";
 
 // ../client/src/lib/chat-utils.ts
 import { clsx } from "clsx";
@@ -562,19 +520,2592 @@ function getDefaultTemperatureByProvider(provider) {
   }
 }
 
-// routes/mcp/chat.ts
-var DEBUG_ENABLED = process.env.MCP_DEBUG !== "false";
-var ELICITATION_TIMEOUT = 3e5;
-var MAX_AGENT_STEPS = 10;
-var dbg = (...args) => {
-  if (DEBUG_ENABLED) console.log("[mcp/chat]", ...args);
-};
-try {
-  process.setMaxListeners?.(50);
-} catch {
-}
-var pendingElicitations2 = /* @__PURE__ */ new Map();
-var chat = new Hono6();
+// node_modules/ai-v5/node_modules/@ai-sdk/provider/dist/index.mjs
+var marker = "vercel.ai.error";
+var symbol = Symbol.for(marker);
+var _a;
+var _AISDKError = class _AISDKError2 extends Error {
+  /**
+   * Creates an AI SDK Error.
+   *
+   * @param {Object} params - The parameters for creating the error.
+   * @param {string} params.name - The name of the error.
+   * @param {string} params.message - The error message.
+   * @param {unknown} [params.cause] - The underlying cause of the error.
+   */
+  constructor({
+    name: name143,
+    message,
+    cause
+  }) {
+    super(message);
+    this[_a] = true;
+    this.name = name143;
+    this.cause = cause;
+  }
+  /**
+   * Checks if the given error is an AI SDK Error.
+   * @param {unknown} error - The error to check.
+   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
+   */
+  static isInstance(error) {
+    return _AISDKError2.hasMarker(error, marker);
+  }
+  static hasMarker(error, marker153) {
+    const markerSymbol = Symbol.for(marker153);
+    return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
+  }
+};
+_a = symbol;
+var AISDKError = _AISDKError;
+var name = "AI_APICallError";
+var marker2 = `vercel.ai.error.${name}`;
+var symbol2 = Symbol.for(marker2);
+var _a2;
+_a2 = symbol2;
+var name2 = "AI_EmptyResponseBodyError";
+var marker3 = `vercel.ai.error.${name2}`;
+var symbol3 = Symbol.for(marker3);
+var _a3;
+_a3 = symbol3;
+function getErrorMessage(error) {
+  if (error == null) {
+    return "unknown error";
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return JSON.stringify(error);
+}
+var name3 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name3}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+var InvalidArgumentError = class extends AISDKError {
+  constructor({
+    message,
+    cause,
+    argument
+  }) {
+    super({ name: name3, message, cause });
+    this[_a4] = true;
+    this.argument = argument;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker4);
+  }
+};
+_a4 = symbol4;
+var name4 = "AI_InvalidPromptError";
+var marker5 = `vercel.ai.error.${name4}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
+_a5 = symbol5;
+var name5 = "AI_InvalidResponseDataError";
+var marker6 = `vercel.ai.error.${name5}`;
+var symbol6 = Symbol.for(marker6);
+var _a6;
+_a6 = symbol6;
+var name6 = "AI_JSONParseError";
+var marker7 = `vercel.ai.error.${name6}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+var JSONParseError = class extends AISDKError {
+  constructor({ text: text2, cause }) {
+    super({
+      name: name6,
+      message: `JSON parsing failed: Text: ${text2}.
+Error message: ${getErrorMessage(cause)}`,
+      cause
+    });
+    this[_a7] = true;
+    this.text = text2;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker7);
+  }
+};
+_a7 = symbol7;
+var name7 = "AI_LoadAPIKeyError";
+var marker8 = `vercel.ai.error.${name7}`;
+var symbol8 = Symbol.for(marker8);
+var _a8;
+_a8 = symbol8;
+var name8 = "AI_LoadSettingError";
+var marker9 = `vercel.ai.error.${name8}`;
+var symbol9 = Symbol.for(marker9);
+var _a9;
+_a9 = symbol9;
+var name9 = "AI_NoContentGeneratedError";
+var marker10 = `vercel.ai.error.${name9}`;
+var symbol10 = Symbol.for(marker10);
+var _a10;
+_a10 = symbol10;
+var name10 = "AI_NoSuchModelError";
+var marker11 = `vercel.ai.error.${name10}`;
+var symbol11 = Symbol.for(marker11);
+var _a11;
+_a11 = symbol11;
+var name11 = "AI_TooManyEmbeddingValuesForCallError";
+var marker12 = `vercel.ai.error.${name11}`;
+var symbol12 = Symbol.for(marker12);
+var _a12;
+_a12 = symbol12;
+var name12 = "AI_TypeValidationError";
+var marker13 = `vercel.ai.error.${name12}`;
+var symbol13 = Symbol.for(marker13);
+var _a13;
+var _TypeValidationError = class _TypeValidationError2 extends AISDKError {
+  constructor({ value, cause }) {
+    super({
+      name: name12,
+      message: `Type validation failed: Value: ${JSON.stringify(value)}.
+Error message: ${getErrorMessage(cause)}`,
+      cause
+    });
+    this[_a13] = true;
+    this.value = value;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker13);
+  }
+  /**
+   * Wraps an error into a TypeValidationError.
+   * If the cause is already a TypeValidationError with the same value, it returns the cause.
+   * Otherwise, it creates a new TypeValidationError.
+   *
+   * @param {Object} params - The parameters for wrapping the error.
+   * @param {unknown} params.value - The value that failed validation.
+   * @param {unknown} params.cause - The original error or cause of the validation failure.
+   * @returns {TypeValidationError} A TypeValidationError instance.
+   */
+  static wrap({
+    value,
+    cause
+  }) {
+    return _TypeValidationError2.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError2({ value, cause });
+  }
+};
+_a13 = symbol13;
+var TypeValidationError = _TypeValidationError;
+var name13 = "AI_UnsupportedFunctionalityError";
+var marker14 = `vercel.ai.error.${name13}`;
+var symbol14 = Symbol.for(marker14);
+var _a14;
+_a14 = symbol14;
+
+// node_modules/ai-v5/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+import * as z4 from "zod/v4";
+import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod/v3";
+import { ZodFirstPartyTypeKind } from "zod/v3";
+import {
+  ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2
+} from "zod/v3";
+var createIdGenerator = ({
+  prefix,
+  size = 16,
+  alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  separator = "-"
+} = {}) => {
+  const generator = () => {
+    const alphabetLength = alphabet.length;
+    const chars = new Array(size);
+    for (let i = 0; i < size; i++) {
+      chars[i] = alphabet[Math.random() * alphabetLength | 0];
+    }
+    return chars.join("");
+  };
+  if (prefix == null) {
+    return generator;
+  }
+  if (alphabet.includes(separator)) {
+    throw new InvalidArgumentError({
+      argument: "separator",
+      message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
+    });
+  }
+  return () => `${prefix}${separator}${generator()}`;
+};
+var generateId = createIdGenerator();
+var suspectProtoRx = /"__proto__"\s*:/;
+var suspectConstructorRx = /"constructor"\s*:/;
+function _parse(text2) {
+  const obj = JSON.parse(text2);
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (suspectProtoRx.test(text2) === false && suspectConstructorRx.test(text2) === false) {
+    return obj;
+  }
+  return filter(obj);
+}
+function filter(obj) {
+  let next = [obj];
+  while (next.length) {
+    const nodes = next;
+    next = [];
+    for (const node of nodes) {
+      if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      for (const key in node) {
+        const value = node[key];
+        if (value && typeof value === "object") {
+          next.push(value);
+        }
+      }
+    }
+  }
+  return obj;
+}
+function secureJsonParse(text2) {
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  try {
+    return _parse(text2);
+  } finally {
+    Error.stackTraceLimit = stackTraceLimit;
+  }
+}
+var validatorSymbol = Symbol.for("vercel.ai.validator");
+function validator(validate) {
+  return { [validatorSymbol]: true, validate };
+}
+function isValidator(value) {
+  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
+}
+function asValidator(value) {
+  return isValidator(value) ? value : standardSchemaValidator(value);
+}
+function standardSchemaValidator(standardSchema) {
+  return validator(async (value) => {
+    const result = await standardSchema["~standard"].validate(value);
+    return result.issues == null ? { success: true, value: result.value } : {
+      success: false,
+      error: new TypeValidationError({
+        value,
+        cause: result.issues
+      })
+    };
+  });
+}
+async function safeValidateTypes({
+  value,
+  schema
+}) {
+  const validator2 = asValidator(schema);
+  try {
+    if (validator2.validate == null) {
+      return { success: true, value, rawValue: value };
+    }
+    const result = await validator2.validate(value);
+    if (result.success) {
+      return { success: true, value: result.value, rawValue: value };
+    }
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: result.error }),
+      rawValue: value
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: error }),
+      rawValue: value
+    };
+  }
+}
+async function safeParseJSON({
+  text: text2,
+  schema
+}) {
+  try {
+    const value = secureJsonParse(text2);
+    if (schema == null) {
+      return { success: true, value, rawValue: value };
+    }
+    return await safeValidateTypes({ value, schema });
+  } catch (error) {
+    return {
+      success: false,
+      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text: text2, cause: error }),
+      rawValue: void 0
+    };
+  }
+}
+var getRelativePath = (pathA, pathB) => {
+  let i = 0;
+  for (; i < pathA.length && i < pathB.length; i++) {
+    if (pathA[i] !== pathB[i])
+      break;
+  }
+  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
+};
+var ignoreOverride = Symbol(
+  "Let zodToJsonSchema decide on which parser to use"
+);
+var defaultOptions = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: true,
+  rejectedAdditionalProperties: false,
+  definitionPath: "definitions",
+  strictUnions: false,
+  definitions: {},
+  errorMessages: false,
+  patternStrategy: "escape",
+  applyRegexFlags: false,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref"
+};
+var getDefaultOptions = (options) => typeof options === "string" ? {
+  ...defaultOptions,
+  name: options
+} : {
+  ...defaultOptions,
+  ...options
+};
+function parseAnyDef() {
+  return {};
+}
+function parseArrayDef(def, refs) {
+  var _a17, _b, _c;
+  const res = {
+    type: "array"
+  };
+  if (((_a17 = def.type) == null ? void 0 : _a17._def) && ((_c = (_b = def.type) == null ? void 0 : _b._def) == null ? void 0 : _c.typeName) !== ZodFirstPartyTypeKind.ZodAny) {
+    res.items = parseDef(def.type._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items"]
+    });
+  }
+  if (def.minLength) {
+    res.minItems = def.minLength.value;
+  }
+  if (def.maxLength) {
+    res.maxItems = def.maxLength.value;
+  }
+  if (def.exactLength) {
+    res.minItems = def.exactLength.value;
+    res.maxItems = def.exactLength.value;
+  }
+  return res;
+}
+function parseBigintDef(def) {
+  const res = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        if (check.inclusive) {
+          res.minimum = check.value;
+        } else {
+          res.exclusiveMinimum = check.value;
+        }
+        break;
+      case "max":
+        if (check.inclusive) {
+          res.maximum = check.value;
+        } else {
+          res.exclusiveMaximum = check.value;
+        }
+        break;
+      case "multipleOf":
+        res.multipleOf = check.value;
+        break;
+    }
+  }
+  return res;
+}
+function parseBooleanDef() {
+  return { type: "boolean" };
+}
+function parseBrandedDef(_def, refs) {
+  return parseDef(_def.type._def, refs);
+}
+var parseCatchDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+function parseDateDef(def, refs, overrideDateStrategy) {
+  const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
+  if (Array.isArray(strategy)) {
+    return {
+      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
+    };
+  }
+  switch (strategy) {
+    case "string":
+    case "format:date-time":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "format:date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "integer":
+      return integerDateParser(def);
+  }
+}
+var integerDateParser = (def) => {
+  const res = {
+    type: "integer",
+    format: "unix-time"
+  };
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        res.minimum = check.value;
+        break;
+      case "max":
+        res.maximum = check.value;
+        break;
+    }
+  }
+  return res;
+};
+function parseDefaultDef(_def, refs) {
+  return {
+    ...parseDef(_def.innerType._def, refs),
+    default: _def.defaultValue()
+  };
+}
+function parseEffectsDef(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef();
+}
+function parseEnumDef(def) {
+  return {
+    type: "string",
+    enum: Array.from(def.values)
+  };
+}
+var isJsonSchema7AllOfType = (type) => {
+  if ("type" in type && type.type === "string")
+    return false;
+  return "allOf" in type;
+};
+function parseIntersectionDef(def, refs) {
+  const allOf = [
+    parseDef(def.left._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "0"]
+    }),
+    parseDef(def.right._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "1"]
+    })
+  ].filter((x) => !!x);
+  const mergedAllOf = [];
+  allOf.forEach((schema) => {
+    if (isJsonSchema7AllOfType(schema)) {
+      mergedAllOf.push(...schema.allOf);
+    } else {
+      let nestedSchema = schema;
+      if ("additionalProperties" in schema && schema.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema;
+        nestedSchema = rest;
+      }
+      mergedAllOf.push(nestedSchema);
+    }
+  });
+  return mergedAllOf.length ? { allOf: mergedAllOf } : void 0;
+}
+function parseLiteralDef(def) {
+  const parsedType = typeof def.value;
+  if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
+    return {
+      type: Array.isArray(def.value) ? "array" : "object"
+    };
+  }
+  return {
+    type: parsedType === "bigint" ? "integer" : parsedType,
+    const: def.value
+  };
+}
+var emojiRegex = void 0;
+var zodPatterns = {
+  /**
+   * `c` was changed to `[cC]` to replicate /i flag
+   */
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  /**
+   * `a-z` was added to replicate /i flag
+   */
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  /**
+   * Constructed a valid Unicode RegExp
+   *
+   * Lazily instantiate since this type of regex isn't supported
+   * in all envs (e.g. React Native).
+   *
+   * See:
+   * https://github.com/colinhacks/zod/issues/2433
+   * Fix in Zod:
+   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+   */
+  emoji: () => {
+    if (emojiRegex === void 0) {
+      emojiRegex = RegExp(
+        "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
+        "u"
+      );
+    }
+    return emojiRegex;
+  },
+  /**
+   * Unused
+   */
+  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+  /**
+   * Unused
+   */
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+  /**
+   * Unused
+   */
+  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+  nanoid: /^[a-zA-Z0-9_-]{21}$/,
+  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function parseStringDef(def, refs) {
+  const res = {
+    type: "string"
+  };
+  if (def.checks) {
+    for (const check of def.checks) {
+      switch (check.kind) {
+        case "min":
+          res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value;
+          break;
+        case "max":
+          res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value;
+          break;
+        case "email":
+          switch (refs.emailStrategy) {
+            case "format:email":
+              addFormat(res, "email", check.message, refs);
+              break;
+            case "format:idn-email":
+              addFormat(res, "idn-email", check.message, refs);
+              break;
+            case "pattern:zod":
+              addPattern(res, zodPatterns.email, check.message, refs);
+              break;
+          }
+          break;
+        case "url":
+          addFormat(res, "uri", check.message, refs);
+          break;
+        case "uuid":
+          addFormat(res, "uuid", check.message, refs);
+          break;
+        case "regex":
+          addPattern(res, check.regex, check.message, refs);
+          break;
+        case "cuid":
+          addPattern(res, zodPatterns.cuid, check.message, refs);
+          break;
+        case "cuid2":
+          addPattern(res, zodPatterns.cuid2, check.message, refs);
+          break;
+        case "startsWith":
+          addPattern(
+            res,
+            RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`),
+            check.message,
+            refs
+          );
+          break;
+        case "endsWith":
+          addPattern(
+            res,
+            RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`),
+            check.message,
+            refs
+          );
+          break;
+        case "datetime":
+          addFormat(res, "date-time", check.message, refs);
+          break;
+        case "date":
+          addFormat(res, "date", check.message, refs);
+          break;
+        case "time":
+          addFormat(res, "time", check.message, refs);
+          break;
+        case "duration":
+          addFormat(res, "duration", check.message, refs);
+          break;
+        case "length":
+          res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value;
+          res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value;
+          break;
+        case "includes": {
+          addPattern(
+            res,
+            RegExp(escapeLiteralCheckValue(check.value, refs)),
+            check.message,
+            refs
+          );
+          break;
+        }
+        case "ip": {
+          if (check.version !== "v6") {
+            addFormat(res, "ipv4", check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addFormat(res, "ipv6", check.message, refs);
+          }
+          break;
+        }
+        case "base64url":
+          addPattern(res, zodPatterns.base64url, check.message, refs);
+          break;
+        case "jwt":
+          addPattern(res, zodPatterns.jwt, check.message, refs);
+          break;
+        case "cidr": {
+          if (check.version !== "v6") {
+            addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
+          }
+          break;
+        }
+        case "emoji":
+          addPattern(res, zodPatterns.emoji(), check.message, refs);
+          break;
+        case "ulid": {
+          addPattern(res, zodPatterns.ulid, check.message, refs);
+          break;
+        }
+        case "base64": {
+          switch (refs.base64Strategy) {
+            case "format:binary": {
+              addFormat(res, "binary", check.message, refs);
+              break;
+            }
+            case "contentEncoding:base64": {
+              res.contentEncoding = "base64";
+              break;
+            }
+            case "pattern:zod": {
+              addPattern(res, zodPatterns.base64, check.message, refs);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid": {
+          addPattern(res, zodPatterns.nanoid, check.message, refs);
+        }
+        case "toLowerCase":
+        case "toUpperCase":
+        case "trim":
+          break;
+        default:
+          /* @__PURE__ */ ((_) => {
+          })(check);
+      }
+    }
+  }
+  return res;
+}
+function escapeLiteralCheckValue(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+}
+var ALPHA_NUMERIC = new Set(
+  "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
+);
+function escapeNonAlphaNumeric(source) {
+  let result = "";
+  for (let i = 0; i < source.length; i++) {
+    if (!ALPHA_NUMERIC.has(source[i])) {
+      result += "\\";
+    }
+    result += source[i];
+  }
+  return result;
+}
+function addFormat(schema, value, message, refs) {
+  var _a17;
+  if (schema.format || ((_a17 = schema.anyOf) == null ? void 0 : _a17.some((x) => x.format))) {
+    if (!schema.anyOf) {
+      schema.anyOf = [];
+    }
+    if (schema.format) {
+      schema.anyOf.push({
+        format: schema.format
+      });
+      delete schema.format;
+    }
+    schema.anyOf.push({
+      format: value,
+      ...message && refs.errorMessages && { errorMessage: { format: message } }
+    });
+  } else {
+    schema.format = value;
+  }
+}
+function addPattern(schema, regex, message, refs) {
+  var _a17;
+  if (schema.pattern || ((_a17 = schema.allOf) == null ? void 0 : _a17.some((x) => x.pattern))) {
+    if (!schema.allOf) {
+      schema.allOf = [];
+    }
+    if (schema.pattern) {
+      schema.allOf.push({
+        pattern: schema.pattern
+      });
+      delete schema.pattern;
+    }
+    schema.allOf.push({
+      pattern: stringifyRegExpWithFlags(regex, refs),
+      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
+    });
+  } else {
+    schema.pattern = stringifyRegExpWithFlags(regex, refs);
+  }
+}
+function stringifyRegExpWithFlags(regex, refs) {
+  var _a17;
+  if (!refs.applyRegexFlags || !regex.flags) {
+    return regex.source;
+  }
+  const flags = {
+    i: regex.flags.includes("i"),
+    // Case-insensitive
+    m: regex.flags.includes("m"),
+    // `^` and `$` matches adjacent to newline characters
+    s: regex.flags.includes("s")
+    // `.` matches newlines
+  };
+  const source = flags.i ? regex.source.toLowerCase() : regex.source;
+  let pattern = "";
+  let isEscaped = false;
+  let inCharGroup = false;
+  let inCharRange = false;
+  for (let i = 0; i < source.length; i++) {
+    if (isEscaped) {
+      pattern += source[i];
+      isEscaped = false;
+      continue;
+    }
+    if (flags.i) {
+      if (inCharGroup) {
+        if (source[i].match(/[a-z]/)) {
+          if (inCharRange) {
+            pattern += source[i];
+            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+            inCharRange = false;
+          } else if (source[i + 1] === "-" && ((_a17 = source[i + 2]) == null ? void 0 : _a17.match(/[a-z]/))) {
+            pattern += source[i];
+            inCharRange = true;
+          } else {
+            pattern += `${source[i]}${source[i].toUpperCase()}`;
+          }
+          continue;
+        }
+      } else if (source[i].match(/[a-z]/)) {
+        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (flags.m) {
+      if (source[i] === "^") {
+        pattern += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (source[i] === "$") {
+        pattern += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (flags.s && source[i] === ".") {
+      pattern += inCharGroup ? `${source[i]}\r
+` : `[${source[i]}\r
+]`;
+      continue;
+    }
+    pattern += source[i];
+    if (source[i] === "\\") {
+      isEscaped = true;
+    } else if (inCharGroup && source[i] === "]") {
+      inCharGroup = false;
+    } else if (!inCharGroup && source[i] === "[") {
+      inCharGroup = true;
+    }
+  }
+  try {
+    new RegExp(pattern);
+  } catch (e) {
+    console.warn(
+      `Could not convert regex pattern at ${refs.currentPath.join(
+        "/"
+      )} to a flag-independent form! Falling back to the flag-ignorant source`
+    );
+    return regex.source;
+  }
+  return pattern;
+}
+function parseRecordDef(def, refs) {
+  var _a17, _b, _c, _d, _e, _f;
+  const schema = {
+    type: "object",
+    additionalProperties: (_a17 = parseDef(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    })) != null ? _a17 : refs.allowedAdditionalProperties
+  };
+  if (((_b = def.keyType) == null ? void 0 : _b._def.typeName) === ZodFirstPartyTypeKind2.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
+    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === ZodFirstPartyTypeKind2.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values
+      }
+    };
+  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
+    const { type, ...keyType } = parseBrandedDef(
+      def.keyType._def,
+      refs
+    );
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  }
+  return schema;
+}
+function parseMapDef(def, refs) {
+  if (refs.mapStrategy === "record") {
+    return parseRecordDef(def, refs);
+  }
+  const keys = parseDef(def.keyType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "0"]
+  }) || parseAnyDef();
+  const values = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "1"]
+  }) || parseAnyDef();
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+function parseNativeEnumDef(def) {
+  const object2 = def.values;
+  const actualKeys = Object.keys(def.values).filter((key) => {
+    return typeof object2[object2[key]] !== "number";
+  });
+  const actualValues = actualKeys.map((key) => object2[key]);
+  const parsedTypes = Array.from(
+    new Set(actualValues.map((values) => typeof values))
+  );
+  return {
+    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
+    enum: actualValues
+  };
+}
+function parseNeverDef() {
+  return { not: parseAnyDef() };
+}
+function parseNullDef() {
+  return {
+    type: "null"
+  };
+}
+var primitiveMappings = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null"
+};
+function parseUnionDef(def, refs) {
+  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+  if (options.every(
+    (x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length)
+  )) {
+    const types = options.reduce((types2, x) => {
+      const type = primitiveMappings[x._def.typeName];
+      return type && !types2.includes(type) ? [...types2, type] : types2;
+    }, []);
+    return {
+      type: types.length > 1 ? types : types[0]
+    };
+  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+    const types = options.reduce(
+      (acc, x) => {
+        const type = typeof x._def.value;
+        switch (type) {
+          case "string":
+          case "number":
+          case "boolean":
+            return [...acc, type];
+          case "bigint":
+            return [...acc, "integer"];
+          case "object":
+            if (x._def.value === null)
+              return [...acc, "null"];
+          case "symbol":
+          case "undefined":
+          case "function":
+          default:
+            return acc;
+        }
+      },
+      []
+    );
+    if (types.length === options.length) {
+      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+      return {
+        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+        enum: options.reduce(
+          (acc, x) => {
+            return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+          },
+          []
+        )
+      };
+    }
+  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
+    return {
+      type: "string",
+      enum: options.reduce(
+        (acc, x) => [
+          ...acc,
+          ...x._def.values.filter((x2) => !acc.includes(x2))
+        ],
+        []
+      )
+    };
+  }
+  return asAnyOf(def, refs);
+}
+var asAnyOf = (def, refs) => {
+  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map(
+    (x, i) => parseDef(x._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "anyOf", `${i}`]
+    })
+  ).filter(
+    (x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0)
+  );
+  return anyOf.length ? { anyOf } : void 0;
+};
+function parseNullableDef(def, refs) {
+  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
+    def.innerType._def.typeName
+  ) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
+    return {
+      type: [
+        primitiveMappings[def.innerType._def.typeName],
+        "null"
+      ]
+    };
+  }
+  const base = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "0"]
+  });
+  return base && { anyOf: [base, { type: "null" }] };
+}
+function parseNumberDef(def) {
+  const res = {
+    type: "number"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "int":
+        res.type = "integer";
+        break;
+      case "min":
+        if (check.inclusive) {
+          res.minimum = check.value;
+        } else {
+          res.exclusiveMinimum = check.value;
+        }
+        break;
+      case "max":
+        if (check.inclusive) {
+          res.maximum = check.value;
+        } else {
+          res.exclusiveMaximum = check.value;
+        }
+        break;
+      case "multipleOf":
+        res.multipleOf = check.value;
+        break;
+    }
+  }
+  return res;
+}
+function parseObjectDef(def, refs) {
+  const result = {
+    type: "object",
+    properties: {}
+  };
+  const required = [];
+  const shape = def.shape();
+  for (const propName in shape) {
+    let propDef = shape[propName];
+    if (propDef === void 0 || propDef._def === void 0) {
+      continue;
+    }
+    const propOptional = safeIsOptional(propDef);
+    const parsedDef = parseDef(propDef._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "properties", propName],
+      propertyPath: [...refs.currentPath, "properties", propName]
+    });
+    if (parsedDef === void 0) {
+      continue;
+    }
+    result.properties[propName] = parsedDef;
+    if (!propOptional) {
+      required.push(propName);
+    }
+  }
+  if (required.length) {
+    result.required = required;
+  }
+  const additionalProperties = decideAdditionalProperties(def, refs);
+  if (additionalProperties !== void 0) {
+    result.additionalProperties = additionalProperties;
+  }
+  return result;
+}
+function decideAdditionalProperties(def, refs) {
+  if (def.catchall._def.typeName !== "ZodNever") {
+    return parseDef(def.catchall._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    });
+  }
+  switch (def.unknownKeys) {
+    case "passthrough":
+      return refs.allowedAdditionalProperties;
+    case "strict":
+      return refs.rejectedAdditionalProperties;
+    case "strip":
+      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
+  }
+}
+function safeIsOptional(schema) {
+  try {
+    return schema.isOptional();
+  } catch (e) {
+    return true;
+  }
+}
+var parseOptionalDef = (def, refs) => {
+  var _a17;
+  if (refs.currentPath.toString() === ((_a17 = refs.propertyPath) == null ? void 0 : _a17.toString())) {
+    return parseDef(def.innerType._def, refs);
+  }
+  const innerSchema = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "1"]
+  });
+  return innerSchema ? { anyOf: [{ not: parseAnyDef() }, innerSchema] } : parseAnyDef();
+};
+var parsePipelineDef = (def, refs) => {
+  if (refs.pipeStrategy === "input") {
+    return parseDef(def.in._def, refs);
+  } else if (refs.pipeStrategy === "output") {
+    return parseDef(def.out._def, refs);
+  }
+  const a = parseDef(def.in._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", "0"]
+  });
+  const b = parseDef(def.out._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
+  });
+  return {
+    allOf: [a, b].filter((x) => x !== void 0)
+  };
+};
+function parsePromiseDef(def, refs) {
+  return parseDef(def.type._def, refs);
+}
+function parseSetDef(def, refs) {
+  const items = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items"]
+  });
+  const schema = {
+    type: "array",
+    uniqueItems: true,
+    items
+  };
+  if (def.minSize) {
+    schema.minItems = def.minSize.value;
+  }
+  if (def.maxSize) {
+    schema.maxItems = def.maxSize.value;
+  }
+  return schema;
+}
+function parseTupleDef(def, refs) {
+  if (def.rest) {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      items: def.items.map(
+        (x, i) => parseDef(x._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, "items", `${i}`]
+        })
+      ).reduce(
+        (acc, x) => x === void 0 ? acc : [...acc, x],
+        []
+      ),
+      additionalItems: parseDef(def.rest._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "additionalItems"]
+      })
+    };
+  } else {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      maxItems: def.items.length,
+      items: def.items.map(
+        (x, i) => parseDef(x._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, "items", `${i}`]
+        })
+      ).reduce(
+        (acc, x) => x === void 0 ? acc : [...acc, x],
+        []
+      )
+    };
+  }
+}
+function parseUndefinedDef() {
+  return {
+    not: parseAnyDef()
+  };
+}
+function parseUnknownDef() {
+  return parseAnyDef();
+}
+var parseReadonlyDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+var selectParser = (def, typeName, refs) => {
+  switch (typeName) {
+    case ZodFirstPartyTypeKind3.ZodString:
+      return parseStringDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodNumber:
+      return parseNumberDef(def);
+    case ZodFirstPartyTypeKind3.ZodObject:
+      return parseObjectDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodBigInt:
+      return parseBigintDef(def);
+    case ZodFirstPartyTypeKind3.ZodBoolean:
+      return parseBooleanDef();
+    case ZodFirstPartyTypeKind3.ZodDate:
+      return parseDateDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodUndefined:
+      return parseUndefinedDef();
+    case ZodFirstPartyTypeKind3.ZodNull:
+      return parseNullDef();
+    case ZodFirstPartyTypeKind3.ZodArray:
+      return parseArrayDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodUnion:
+    case ZodFirstPartyTypeKind3.ZodDiscriminatedUnion:
+      return parseUnionDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodIntersection:
+      return parseIntersectionDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodTuple:
+      return parseTupleDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodRecord:
+      return parseRecordDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodLiteral:
+      return parseLiteralDef(def);
+    case ZodFirstPartyTypeKind3.ZodEnum:
+      return parseEnumDef(def);
+    case ZodFirstPartyTypeKind3.ZodNativeEnum:
+      return parseNativeEnumDef(def);
+    case ZodFirstPartyTypeKind3.ZodNullable:
+      return parseNullableDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodOptional:
+      return parseOptionalDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodMap:
+      return parseMapDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodSet:
+      return parseSetDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodLazy:
+      return () => def.getter()._def;
+    case ZodFirstPartyTypeKind3.ZodPromise:
+      return parsePromiseDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodNaN:
+    case ZodFirstPartyTypeKind3.ZodNever:
+      return parseNeverDef();
+    case ZodFirstPartyTypeKind3.ZodEffects:
+      return parseEffectsDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodAny:
+      return parseAnyDef();
+    case ZodFirstPartyTypeKind3.ZodUnknown:
+      return parseUnknownDef();
+    case ZodFirstPartyTypeKind3.ZodDefault:
+      return parseDefaultDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodBranded:
+      return parseBrandedDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodReadonly:
+      return parseReadonlyDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodCatch:
+      return parseCatchDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodPipeline:
+      return parsePipelineDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodFunction:
+    case ZodFirstPartyTypeKind3.ZodVoid:
+    case ZodFirstPartyTypeKind3.ZodSymbol:
+      return void 0;
+    default:
+      return /* @__PURE__ */ ((_) => void 0)(typeName);
+  }
+};
+function parseDef(def, refs, forceResolution = false) {
+  var _a17;
+  const seenItem = refs.seen.get(def);
+  if (refs.override) {
+    const overrideResult = (_a17 = refs.override) == null ? void 0 : _a17.call(
+      refs,
+      def,
+      refs,
+      seenItem,
+      forceResolution
+    );
+    if (overrideResult !== ignoreOverride) {
+      return overrideResult;
+    }
+  }
+  if (seenItem && !forceResolution) {
+    const seenSchema = get$ref(seenItem, refs);
+    if (seenSchema !== void 0) {
+      return seenSchema;
+    }
+  }
+  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
+  refs.seen.set(def, newItem);
+  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
+  const jsonSchema2 = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  if (jsonSchema2) {
+    addMeta(def, refs, jsonSchema2);
+  }
+  if (refs.postProcess) {
+    const postProcessResult = refs.postProcess(jsonSchema2, def, refs);
+    newItem.jsonSchema = jsonSchema2;
+    return postProcessResult;
+  }
+  newItem.jsonSchema = jsonSchema2;
+  return jsonSchema2;
+}
+var get$ref = (item, refs) => {
+  switch (refs.$refStrategy) {
+    case "root":
+      return { $ref: item.path.join("/") };
+    case "relative":
+      return { $ref: getRelativePath(refs.currentPath, item.path) };
+    case "none":
+    case "seen": {
+      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
+        console.warn(
+          `Recursive reference detected at ${refs.currentPath.join(
+            "/"
+          )}! Defaulting to any`
+        );
+        return parseAnyDef();
+      }
+      return refs.$refStrategy === "seen" ? parseAnyDef() : void 0;
+    }
+  }
+};
+var addMeta = (def, refs, jsonSchema2) => {
+  if (def.description) {
+    jsonSchema2.description = def.description;
+  }
+  return jsonSchema2;
+};
+var getRefs = (options) => {
+  const _options = getDefaultOptions(options);
+  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+  return {
+    ..._options,
+    currentPath,
+    propertyPath: void 0,
+    seen: new Map(
+      Object.entries(_options.definitions).map(([name17, def]) => [
+        def._def,
+        {
+          def: def._def,
+          path: [..._options.basePath, _options.definitionPath, name17],
+          // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+          jsonSchema: void 0
+        }
+      ])
+    )
+  };
+};
+var zodToJsonSchema2 = (schema, options) => {
+  var _a17;
+  const refs = getRefs(options);
+  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
+    (acc, [name23, schema2]) => {
+      var _a23;
+      return {
+        ...acc,
+        [name23]: (_a23 = parseDef(
+          schema2._def,
+          {
+            ...refs,
+            currentPath: [...refs.basePath, refs.definitionPath, name23]
+          },
+          true
+        )) != null ? _a23 : parseAnyDef()
+      };
+    },
+    {}
+  ) : void 0;
+  const name17 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
+  const main = (_a17 = parseDef(
+    schema._def,
+    name17 === void 0 ? refs : {
+      ...refs,
+      currentPath: [...refs.basePath, refs.definitionPath, name17]
+    },
+    false
+  )) != null ? _a17 : parseAnyDef();
+  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
+  if (title !== void 0) {
+    main.title = title;
+  }
+  const combined = name17 === void 0 ? definitions ? {
+    ...main,
+    [refs.definitionPath]: definitions
+  } : main : {
+    $ref: [
+      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
+      refs.definitionPath,
+      name17
+    ].join("/"),
+    [refs.definitionPath]: {
+      ...definitions,
+      [name17]: main
+    }
+  };
+  combined.$schema = "http://json-schema.org/draft-07/schema#";
+  return combined;
+};
+var zod_to_json_schema_default = zodToJsonSchema2;
+function zod3Schema(zodSchema2, options) {
+  var _a17;
+  const useReferences = (_a17 = options == null ? void 0 : options.useReferences) != null ? _a17 : false;
+  return jsonSchema(
+    zod_to_json_schema_default(zodSchema2, {
+      $refStrategy: useReferences ? "root" : "none"
+    }),
+    {
+      validate: async (value) => {
+        const result = await zodSchema2.safeParseAsync(value);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    }
+  );
+}
+function zod4Schema(zodSchema2, options) {
+  var _a17;
+  const useReferences = (_a17 = options == null ? void 0 : options.useReferences) != null ? _a17 : false;
+  const z4JSONSchema = z4.toJSONSchema(zodSchema2, {
+    target: "draft-7",
+    io: "output",
+    reused: useReferences ? "ref" : "inline"
+  });
+  return jsonSchema(z4JSONSchema, {
+    validate: async (value) => {
+      const result = await z4.safeParseAsync(zodSchema2, value);
+      return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+    }
+  });
+}
+function isZod4Schema(zodSchema2) {
+  return "_zod" in zodSchema2;
+}
+function zodSchema(zodSchema2, options) {
+  if (isZod4Schema(zodSchema2)) {
+    return zod4Schema(zodSchema2, options);
+  } else {
+    return zod3Schema(zodSchema2, options);
+  }
+}
+var schemaSymbol = Symbol.for("vercel.ai.schema");
+function jsonSchema(jsonSchema2, {
+  validate
+} = {}) {
+  return {
+    [schemaSymbol]: true,
+    _type: void 0,
+    // should never be used directly
+    [validatorSymbol]: true,
+    jsonSchema: jsonSchema2,
+    validate
+  };
+}
+function isSchema(value) {
+  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
+}
+function asSchema(schema) {
+  return schema == null ? jsonSchema({
+    properties: {},
+    additionalProperties: false
+  }) : isSchema(schema) ? schema : zodSchema(schema);
+}
+var { btoa, atob } = globalThis;
+
+// node_modules/ai-v5/dist/index.mjs
+import { z } from "zod/v4";
+import { z as z6 } from "zod/v4";
+import { z as z5 } from "zod/v4";
+import { z as z3 } from "zod/v4";
+import { z as z2 } from "zod/v4";
+import { z as z42 } from "zod/v4";
+import { z as z7 } from "zod/v4";
+import { z as z9 } from "zod/v4";
+import { z as z8 } from "zod/v4";
+import { z as z10 } from "zod/v4";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name17 in all)
+    __defProp(target, name17, { get: all[name17], enumerable: true });
+};
+var name14 = "AI_NoOutputSpecifiedError";
+var marker15 = `vercel.ai.error.${name14}`;
+var symbol15 = Symbol.for(marker15);
+var _a15;
+_a15 = symbol15;
+var name22 = "AI_InvalidArgumentError";
+var marker22 = `vercel.ai.error.${name22}`;
+var symbol22 = Symbol.for(marker22);
+var _a22;
+_a22 = symbol22;
+var name32 = "AI_InvalidStreamPartError";
+var marker32 = `vercel.ai.error.${name32}`;
+var symbol32 = Symbol.for(marker32);
+var _a32;
+_a32 = symbol32;
+var name42 = "AI_InvalidToolInputError";
+var marker42 = `vercel.ai.error.${name42}`;
+var symbol42 = Symbol.for(marker42);
+var _a42;
+_a42 = symbol42;
+var name52 = "AI_MCPClientError";
+var marker52 = `vercel.ai.error.${name52}`;
+var symbol52 = Symbol.for(marker52);
+var _a52;
+_a52 = symbol52;
+var name62 = "AI_NoImageGeneratedError";
+var marker62 = `vercel.ai.error.${name62}`;
+var symbol62 = Symbol.for(marker62);
+var _a62;
+_a62 = symbol62;
+var name72 = "AI_NoObjectGeneratedError";
+var marker72 = `vercel.ai.error.${name72}`;
+var symbol72 = Symbol.for(marker72);
+var _a72;
+var NoObjectGeneratedError = class extends AISDKError {
+  constructor({
+    message = "No object generated.",
+    cause,
+    text: text2,
+    response,
+    usage,
+    finishReason
+  }) {
+    super({ name: name72, message, cause });
+    this[_a72] = true;
+    this.text = text2;
+    this.response = response;
+    this.usage = usage;
+    this.finishReason = finishReason;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker72);
+  }
+};
+_a72 = symbol72;
+var name82 = "AI_NoOutputGeneratedError";
+var marker82 = `vercel.ai.error.${name82}`;
+var symbol82 = Symbol.for(marker82);
+var _a82;
+_a82 = symbol82;
+var name92 = "AI_NoSuchToolError";
+var marker92 = `vercel.ai.error.${name92}`;
+var symbol92 = Symbol.for(marker92);
+var _a92;
+_a92 = symbol92;
+var name102 = "AI_ToolCallRepairError";
+var marker102 = `vercel.ai.error.${name102}`;
+var symbol102 = Symbol.for(marker102);
+var _a102;
+_a102 = symbol102;
+var name112 = "AI_InvalidDataContentError";
+var marker112 = `vercel.ai.error.${name112}`;
+var symbol112 = Symbol.for(marker112);
+var _a112;
+_a112 = symbol112;
+var name122 = "AI_InvalidMessageRoleError";
+var marker122 = `vercel.ai.error.${name122}`;
+var symbol122 = Symbol.for(marker122);
+var _a122;
+_a122 = symbol122;
+var name132 = "AI_MessageConversionError";
+var marker132 = `vercel.ai.error.${name132}`;
+var symbol132 = Symbol.for(marker132);
+var _a132;
+_a132 = symbol132;
+var name142 = "AI_DownloadError";
+var marker142 = `vercel.ai.error.${name142}`;
+var symbol142 = Symbol.for(marker142);
+var _a142;
+_a142 = symbol142;
+var name15 = "AI_RetryError";
+var marker152 = `vercel.ai.error.${name15}`;
+var symbol152 = Symbol.for(marker152);
+var _a152;
+_a152 = symbol152;
+var dataContentSchema = z.union([
+  z.string(),
+  z.instanceof(Uint8Array),
+  z.instanceof(ArrayBuffer),
+  z.custom(
+    // Buffer might not be available in some environments such as CloudFlare:
+    (value) => {
+      var _a17, _b;
+      return (_b = (_a17 = globalThis.Buffer) == null ? void 0 : _a17.isBuffer(value)) != null ? _b : false;
+    },
+    { message: "Must be a Buffer" }
+  )
+]);
+var jsonValueSchema = z2.lazy(
+  () => z2.union([
+    z2.null(),
+    z2.string(),
+    z2.number(),
+    z2.boolean(),
+    z2.record(z2.string(), jsonValueSchema),
+    z2.array(jsonValueSchema)
+  ])
+);
+var providerMetadataSchema = z3.record(
+  z3.string(),
+  z3.record(z3.string(), jsonValueSchema)
+);
+var textPartSchema = z42.object({
+  type: z42.literal("text"),
+  text: z42.string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var imagePartSchema = z42.object({
+  type: z42.literal("image"),
+  image: z42.union([dataContentSchema, z42.instanceof(URL)]),
+  mediaType: z42.string().optional(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var filePartSchema = z42.object({
+  type: z42.literal("file"),
+  data: z42.union([dataContentSchema, z42.instanceof(URL)]),
+  filename: z42.string().optional(),
+  mediaType: z42.string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var reasoningPartSchema = z42.object({
+  type: z42.literal("reasoning"),
+  text: z42.string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var toolCallPartSchema = z42.object({
+  type: z42.literal("tool-call"),
+  toolCallId: z42.string(),
+  toolName: z42.string(),
+  input: z42.unknown(),
+  providerOptions: providerMetadataSchema.optional(),
+  providerExecuted: z42.boolean().optional()
+});
+var outputSchema = z42.discriminatedUnion("type", [
+  z42.object({
+    type: z42.literal("text"),
+    value: z42.string()
+  }),
+  z42.object({
+    type: z42.literal("json"),
+    value: jsonValueSchema
+  }),
+  z42.object({
+    type: z42.literal("error-text"),
+    value: z42.string()
+  }),
+  z42.object({
+    type: z42.literal("error-json"),
+    value: jsonValueSchema
+  }),
+  z42.object({
+    type: z42.literal("content"),
+    value: z42.array(
+      z42.union([
+        z42.object({
+          type: z42.literal("text"),
+          text: z42.string()
+        }),
+        z42.object({
+          type: z42.literal("media"),
+          data: z42.string(),
+          mediaType: z42.string()
+        })
+      ])
+    )
+  })
+]);
+var toolResultPartSchema = z42.object({
+  type: z42.literal("tool-result"),
+  toolCallId: z42.string(),
+  toolName: z42.string(),
+  output: outputSchema,
+  providerOptions: providerMetadataSchema.optional()
+});
+var systemModelMessageSchema = z5.object(
+  {
+    role: z5.literal("system"),
+    content: z5.string(),
+    providerOptions: providerMetadataSchema.optional()
+  }
+);
+var userModelMessageSchema = z5.object({
+  role: z5.literal("user"),
+  content: z5.union([
+    z5.string(),
+    z5.array(z5.union([textPartSchema, imagePartSchema, filePartSchema]))
+  ]),
+  providerOptions: providerMetadataSchema.optional()
+});
+var assistantModelMessageSchema = z5.object({
+  role: z5.literal("assistant"),
+  content: z5.union([
+    z5.string(),
+    z5.array(
+      z5.union([
+        textPartSchema,
+        filePartSchema,
+        reasoningPartSchema,
+        toolCallPartSchema,
+        toolResultPartSchema
+      ])
+    )
+  ]),
+  providerOptions: providerMetadataSchema.optional()
+});
+var toolModelMessageSchema = z5.object({
+  role: z5.literal("tool"),
+  content: z5.array(toolResultPartSchema),
+  providerOptions: providerMetadataSchema.optional()
+});
+var modelMessageSchema = z5.union([
+  systemModelMessageSchema,
+  userModelMessageSchema,
+  assistantModelMessageSchema,
+  toolModelMessageSchema
+]);
+function stepCountIs(stepCount) {
+  return ({ steps }) => steps.length === stepCount;
+}
+var originalGenerateId = createIdGenerator({
+  prefix: "aitxt",
+  size: 24
+});
+var JsonToSseTransformStream = class extends TransformStream {
+  constructor() {
+    super({
+      transform(part, controller) {
+        controller.enqueue(`data: ${JSON.stringify(part)}
+
+`);
+      },
+      flush(controller) {
+        controller.enqueue("data: [DONE]\n\n");
+      }
+    });
+  }
+};
+var uiMessageChunkSchema = z7.union([
+  z7.strictObject({
+    type: z7.literal("text-start"),
+    id: z7.string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("text-delta"),
+    id: z7.string(),
+    delta: z7.string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("text-end"),
+    id: z7.string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("error"),
+    errorText: z7.string()
+  }),
+  z7.strictObject({
+    type: z7.literal("tool-input-start"),
+    toolCallId: z7.string(),
+    toolName: z7.string(),
+    providerExecuted: z7.boolean().optional(),
+    dynamic: z7.boolean().optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("tool-input-delta"),
+    toolCallId: z7.string(),
+    inputTextDelta: z7.string()
+  }),
+  z7.strictObject({
+    type: z7.literal("tool-input-available"),
+    toolCallId: z7.string(),
+    toolName: z7.string(),
+    input: z7.unknown(),
+    providerExecuted: z7.boolean().optional(),
+    providerMetadata: providerMetadataSchema.optional(),
+    dynamic: z7.boolean().optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("tool-input-error"),
+    toolCallId: z7.string(),
+    toolName: z7.string(),
+    input: z7.unknown(),
+    providerExecuted: z7.boolean().optional(),
+    providerMetadata: providerMetadataSchema.optional(),
+    dynamic: z7.boolean().optional(),
+    errorText: z7.string()
+  }),
+  z7.strictObject({
+    type: z7.literal("tool-output-available"),
+    toolCallId: z7.string(),
+    output: z7.unknown(),
+    providerExecuted: z7.boolean().optional(),
+    dynamic: z7.boolean().optional(),
+    preliminary: z7.boolean().optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("tool-output-error"),
+    toolCallId: z7.string(),
+    errorText: z7.string(),
+    providerExecuted: z7.boolean().optional(),
+    dynamic: z7.boolean().optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("reasoning"),
+    text: z7.string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("reasoning-start"),
+    id: z7.string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("reasoning-delta"),
+    id: z7.string(),
+    delta: z7.string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("reasoning-end"),
+    id: z7.string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("reasoning-part-finish")
+  }),
+  z7.strictObject({
+    type: z7.literal("source-url"),
+    sourceId: z7.string(),
+    url: z7.string(),
+    title: z7.string().optional(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("source-document"),
+    sourceId: z7.string(),
+    mediaType: z7.string(),
+    title: z7.string(),
+    filename: z7.string().optional(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("file"),
+    url: z7.string(),
+    mediaType: z7.string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  z7.strictObject({
+    type: z7.string().startsWith("data-"),
+    id: z7.string().optional(),
+    data: z7.unknown(),
+    transient: z7.boolean().optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("start-step")
+  }),
+  z7.strictObject({
+    type: z7.literal("finish-step")
+  }),
+  z7.strictObject({
+    type: z7.literal("start"),
+    messageId: z7.string().optional(),
+    messageMetadata: z7.unknown().optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("finish"),
+    messageMetadata: z7.unknown().optional()
+  }),
+  z7.strictObject({
+    type: z7.literal("abort")
+  }),
+  z7.strictObject({
+    type: z7.literal("message-metadata"),
+    messageMetadata: z7.unknown()
+  })
+]);
+function fixJson(input) {
+  const stack = ["ROOT"];
+  let lastValidIndex = -1;
+  let literalStart = null;
+  function processValueStart(char, i, swapState) {
+    {
+      switch (char) {
+        case '"': {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_STRING");
+          break;
+        }
+        case "f":
+        case "t":
+        case "n": {
+          lastValidIndex = i;
+          literalStart = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_LITERAL");
+          break;
+        }
+        case "-": {
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "0":
+        case "1":
+        case "2":
+        case "3":
+        case "4":
+        case "5":
+        case "6":
+        case "7":
+        case "8":
+        case "9": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "{": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_OBJECT_START");
+          break;
+        }
+        case "[": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_ARRAY_START");
+          break;
+        }
+      }
+    }
+  }
+  function processAfterObjectValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_OBJECT_AFTER_COMMA");
+        break;
+      }
+      case "}": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  function processAfterArrayValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_ARRAY_AFTER_COMMA");
+        break;
+      }
+      case "]": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    const currentState = stack[stack.length - 1];
+    switch (currentState) {
+      case "ROOT":
+        processValueStart(char, i, "FINISH");
+        break;
+      case "INSIDE_OBJECT_START": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+          case "}": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_COMMA": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_KEY": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_AFTER_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_KEY": {
+        switch (char) {
+          case ":": {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_BEFORE_VALUE": {
+        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        processAfterObjectValue(char, i);
+        break;
+      }
+      case "INSIDE_STRING": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            lastValidIndex = i;
+            break;
+          }
+          case "\\": {
+            stack.push("INSIDE_STRING_ESCAPE");
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_START": {
+        switch (char) {
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        switch (char) {
+          case ",": {
+            stack.pop();
+            stack.push("INSIDE_ARRAY_AFTER_COMMA");
+            break;
+          }
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_COMMA": {
+        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_STRING_ESCAPE": {
+        stack.pop();
+        lastValidIndex = i;
+        break;
+      }
+      case "INSIDE_NUMBER": {
+        switch (char) {
+          case "0":
+          case "1":
+          case "2":
+          case "3":
+          case "4":
+          case "5":
+          case "6":
+          case "7":
+          case "8":
+          case "9": {
+            lastValidIndex = i;
+            break;
+          }
+          case "e":
+          case "E":
+          case "-":
+          case ".": {
+            break;
+          }
+          case ",": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "}": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "]": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            break;
+          }
+          default: {
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, i + 1);
+        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
+          stack.pop();
+          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+            processAfterObjectValue(char, i);
+          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+            processAfterArrayValue(char, i);
+          }
+        } else {
+          lastValidIndex = i;
+        }
+        break;
+      }
+    }
+  }
+  let result = input.slice(0, lastValidIndex + 1);
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const state = stack[i];
+    switch (state) {
+      case "INSIDE_STRING": {
+        result += '"';
+        break;
+      }
+      case "INSIDE_OBJECT_KEY":
+      case "INSIDE_OBJECT_AFTER_KEY":
+      case "INSIDE_OBJECT_AFTER_COMMA":
+      case "INSIDE_OBJECT_START":
+      case "INSIDE_OBJECT_BEFORE_VALUE":
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        result += "}";
+        break;
+      }
+      case "INSIDE_ARRAY_START":
+      case "INSIDE_ARRAY_AFTER_COMMA":
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        result += "]";
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, input.length);
+        if ("true".startsWith(partialLiteral)) {
+          result += "true".slice(partialLiteral.length);
+        } else if ("false".startsWith(partialLiteral)) {
+          result += "false".slice(partialLiteral.length);
+        } else if ("null".startsWith(partialLiteral)) {
+          result += "null".slice(partialLiteral.length);
+        }
+      }
+    }
+  }
+  return result;
+}
+async function parsePartialJson(jsonText) {
+  if (jsonText === void 0) {
+    return { value: void 0, state: "undefined-input" };
+  }
+  let result = await safeParseJSON({ text: jsonText });
+  if (result.success) {
+    return { value: result.value, state: "successful-parse" };
+  }
+  result = await safeParseJSON({ text: fixJson(jsonText) });
+  if (result.success) {
+    return { value: result.value, state: "repaired-parse" };
+  }
+  return { value: void 0, state: "failed-parse" };
+}
+var originalGenerateId2 = createIdGenerator({
+  prefix: "aitxt",
+  size: 24
+});
+var originalGenerateId3 = createIdGenerator({ prefix: "aiobj", size: 24 });
+var originalGenerateId4 = createIdGenerator({ prefix: "aiobj", size: 24 });
+var output_exports = {};
+__export(output_exports, {
+  object: () => object,
+  text: () => text
+});
+var text = () => ({
+  type: "text",
+  responseFormat: { type: "text" },
+  async parsePartial({ text: text2 }) {
+    return { partial: text2 };
+  },
+  async parseOutput({ text: text2 }) {
+    return text2;
+  }
+});
+var object = ({
+  schema: inputSchema
+}) => {
+  const schema = asSchema(inputSchema);
+  return {
+    type: "object",
+    responseFormat: {
+      type: "json",
+      schema: schema.jsonSchema
+    },
+    async parsePartial({ text: text2 }) {
+      const result = await parsePartialJson(text2);
+      switch (result.state) {
+        case "failed-parse":
+        case "undefined-input":
+          return void 0;
+        case "repaired-parse":
+        case "successful-parse":
+          return {
+            // Note: currently no validation of partial results:
+            partial: result.value
+          };
+        default: {
+          const _exhaustiveCheck = result.state;
+          throw new Error(`Unsupported parse state: ${_exhaustiveCheck}`);
+        }
+      }
+    },
+    async parseOutput({ text: text2 }, context) {
+      const parseResult = await safeParseJSON({ text: text2 });
+      if (!parseResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: could not parse the response.",
+          cause: parseResult.error,
+          text: text2,
+          response: context.response,
+          usage: context.usage,
+          finishReason: context.finishReason
+        });
+      }
+      const validationResult = await safeValidateTypes({
+        value: parseResult.value,
+        schema
+      });
+      if (!validationResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: response did not match schema.",
+          cause: validationResult.error,
+          text: text2,
+          response: context.response,
+          usage: context.usage,
+          finishReason: context.finishReason
+        });
+      }
+      return validationResult.value;
+    }
+  };
+};
+var name16 = "AI_NoSuchProviderError";
+var marker16 = `vercel.ai.error.${name16}`;
+var symbol16 = Symbol.for(marker16);
+var _a16;
+_a16 = symbol16;
+var ClientOrServerImplementationSchema = z8.looseObject({
+  name: z8.string(),
+  version: z8.string()
+});
+var BaseParamsSchema = z8.looseObject({
+  _meta: z8.optional(z8.object({}).loose())
+});
+var ResultSchema = BaseParamsSchema;
+var RequestSchema = z8.object({
+  method: z8.string(),
+  params: z8.optional(BaseParamsSchema)
+});
+var ServerCapabilitiesSchema = z8.looseObject({
+  experimental: z8.optional(z8.object({}).loose()),
+  logging: z8.optional(z8.object({}).loose()),
+  prompts: z8.optional(
+    z8.looseObject({
+      listChanged: z8.optional(z8.boolean())
+    })
+  ),
+  resources: z8.optional(
+    z8.looseObject({
+      subscribe: z8.optional(z8.boolean()),
+      listChanged: z8.optional(z8.boolean())
+    })
+  ),
+  tools: z8.optional(
+    z8.looseObject({
+      listChanged: z8.optional(z8.boolean())
+    })
+  )
+});
+var InitializeResultSchema = ResultSchema.extend({
+  protocolVersion: z8.string(),
+  capabilities: ServerCapabilitiesSchema,
+  serverInfo: ClientOrServerImplementationSchema,
+  instructions: z8.optional(z8.string())
+});
+var PaginatedResultSchema = ResultSchema.extend({
+  nextCursor: z8.optional(z8.string())
+});
+var ToolSchema = z8.object({
+  name: z8.string(),
+  description: z8.optional(z8.string()),
+  inputSchema: z8.object({
+    type: z8.literal("object"),
+    properties: z8.optional(z8.object({}).loose())
+  }).loose()
+}).loose();
+var ListToolsResultSchema = PaginatedResultSchema.extend({
+  tools: z8.array(ToolSchema)
+});
+var TextContentSchema = z8.object({
+  type: z8.literal("text"),
+  text: z8.string()
+}).loose();
+var ImageContentSchema = z8.object({
+  type: z8.literal("image"),
+  data: z8.base64(),
+  mimeType: z8.string()
+}).loose();
+var ResourceContentsSchema = z8.object({
+  /**
+   * The URI of this resource.
+   */
+  uri: z8.string(),
+  /**
+   * The MIME type of this resource, if known.
+   */
+  mimeType: z8.optional(z8.string())
+}).loose();
+var TextResourceContentsSchema = ResourceContentsSchema.extend({
+  text: z8.string()
+});
+var BlobResourceContentsSchema = ResourceContentsSchema.extend({
+  blob: z8.base64()
+});
+var EmbeddedResourceSchema = z8.object({
+  type: z8.literal("resource"),
+  resource: z8.union([TextResourceContentsSchema, BlobResourceContentsSchema])
+}).loose();
+var CallToolResultSchema = ResultSchema.extend({
+  content: z8.array(
+    z8.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
+  ),
+  isError: z8.boolean().default(false).optional()
+}).or(
+  ResultSchema.extend({
+    toolResult: z8.unknown()
+  })
+);
+var JSONRPC_VERSION = "2.0";
+var JSONRPCRequestSchema = z9.object({
+  jsonrpc: z9.literal(JSONRPC_VERSION),
+  id: z9.union([z9.string(), z9.number().int()])
+}).merge(RequestSchema).strict();
+var JSONRPCResponseSchema = z9.object({
+  jsonrpc: z9.literal(JSONRPC_VERSION),
+  id: z9.union([z9.string(), z9.number().int()]),
+  result: ResultSchema
+}).strict();
+var JSONRPCErrorSchema = z9.object({
+  jsonrpc: z9.literal(JSONRPC_VERSION),
+  id: z9.union([z9.string(), z9.number().int()]),
+  error: z9.object({
+    code: z9.number().int(),
+    message: z9.string(),
+    data: z9.optional(z9.unknown())
+  })
+}).strict();
+var JSONRPCNotificationSchema = z9.object({
+  jsonrpc: z9.literal(JSONRPC_VERSION)
+}).merge(
+  z9.object({
+    method: z9.string(),
+    params: z9.optional(BaseParamsSchema)
+  })
+).strict();
+var JSONRPCMessageSchema = z9.union([
+  JSONRPCRequestSchema,
+  JSONRPCNotificationSchema,
+  JSONRPCResponseSchema,
+  JSONRPCErrorSchema
+]);
+var textUIPartSchema = z10.object({
+  type: z10.literal("text"),
+  text: z10.string(),
+  state: z10.enum(["streaming", "done"]).optional(),
+  providerMetadata: providerMetadataSchema.optional()
+});
+var reasoningUIPartSchema = z10.object({
+  type: z10.literal("reasoning"),
+  text: z10.string(),
+  state: z10.enum(["streaming", "done"]).optional(),
+  providerMetadata: providerMetadataSchema.optional()
+});
+var sourceUrlUIPartSchema = z10.object({
+  type: z10.literal("source-url"),
+  sourceId: z10.string(),
+  url: z10.string(),
+  title: z10.string().optional(),
+  providerMetadata: providerMetadataSchema.optional()
+});
+var sourceDocumentUIPartSchema = z10.object({
+  type: z10.literal("source-document"),
+  sourceId: z10.string(),
+  mediaType: z10.string(),
+  title: z10.string(),
+  filename: z10.string().optional(),
+  providerMetadata: providerMetadataSchema.optional()
+});
+var fileUIPartSchema = z10.object({
+  type: z10.literal("file"),
+  mediaType: z10.string(),
+  filename: z10.string().optional(),
+  url: z10.string(),
+  providerMetadata: providerMetadataSchema.optional()
+});
+var stepStartUIPartSchema = z10.object({
+  type: z10.literal("step-start")
+});
+var dataUIPartSchema = z10.object({
+  type: z10.string().startsWith("data-"),
+  id: z10.string().optional(),
+  data: z10.unknown()
+});
+var dynamicToolUIPartSchemas = [
+  z10.object({
+    type: z10.literal("dynamic-tool"),
+    toolName: z10.string(),
+    toolCallId: z10.string(),
+    state: z10.literal("input-streaming"),
+    input: z10.unknown().optional(),
+    output: z10.never().optional(),
+    errorText: z10.never().optional()
+  }),
+  z10.object({
+    type: z10.literal("dynamic-tool"),
+    toolName: z10.string(),
+    toolCallId: z10.string(),
+    state: z10.literal("input-available"),
+    input: z10.unknown(),
+    output: z10.never().optional(),
+    errorText: z10.never().optional(),
+    callProviderMetadata: providerMetadataSchema.optional()
+  }),
+  z10.object({
+    type: z10.literal("dynamic-tool"),
+    toolName: z10.string(),
+    toolCallId: z10.string(),
+    state: z10.literal("output-available"),
+    input: z10.unknown(),
+    output: z10.unknown(),
+    errorText: z10.never().optional(),
+    callProviderMetadata: providerMetadataSchema.optional(),
+    preliminary: z10.boolean().optional()
+  }),
+  z10.object({
+    type: z10.literal("dynamic-tool"),
+    toolName: z10.string(),
+    toolCallId: z10.string(),
+    state: z10.literal("output-error"),
+    input: z10.unknown(),
+    output: z10.never().optional(),
+    errorText: z10.string(),
+    callProviderMetadata: providerMetadataSchema.optional()
+  })
+];
+var toolUIPartSchemas = [
+  z10.object({
+    type: z10.string().startsWith("tool-"),
+    toolCallId: z10.string(),
+    state: z10.literal("input-streaming"),
+    input: z10.unknown().optional(),
+    output: z10.never().optional(),
+    errorText: z10.never().optional()
+  }),
+  z10.object({
+    type: z10.string().startsWith("tool-"),
+    toolCallId: z10.string(),
+    state: z10.literal("input-available"),
+    input: z10.unknown(),
+    output: z10.never().optional(),
+    errorText: z10.never().optional(),
+    callProviderMetadata: providerMetadataSchema.optional()
+  }),
+  z10.object({
+    type: z10.string().startsWith("tool-"),
+    toolCallId: z10.string(),
+    state: z10.literal("output-available"),
+    input: z10.unknown(),
+    output: z10.unknown(),
+    errorText: z10.never().optional(),
+    callProviderMetadata: providerMetadataSchema.optional(),
+    preliminary: z10.boolean().optional()
+  }),
+  z10.object({
+    type: z10.string().startsWith("tool-"),
+    toolCallId: z10.string(),
+    state: z10.literal("output-error"),
+    input: z10.unknown(),
+    output: z10.never().optional(),
+    errorText: z10.string(),
+    callProviderMetadata: providerMetadataSchema.optional()
+  })
+];
+var uiMessageSchema = z10.object({
+  id: z10.string(),
+  role: z10.enum(["system", "user", "assistant"]),
+  metadata: z10.unknown().optional(),
+  parts: z10.array(
+    z10.union([
+      textUIPartSchema,
+      reasoningUIPartSchema,
+      sourceUrlUIPartSchema,
+      sourceDocumentUIPartSchema,
+      fileUIPartSchema,
+      stepStartUIPartSchema,
+      dataUIPartSchema,
+      ...dynamicToolUIPartSchemas,
+      ...toolUIPartSchemas
+    ])
+  )
+});
+
+// utils/chat-helpers.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOllama } from "ollama-ai-provider";
 var createLlmModel = (modelDefinition, apiKey, ollamaBaseUrl) => {
   if (!modelDefinition?.id || !modelDefinition?.provider) {
     throw new Error(
@@ -605,111 +3136,42 @@ var createLlmModel = (modelDefinition, apiKey, ollamaBaseUrl) => {
       );
   }
 };
-var wrapToolsWithStreaming = (tools2, streamingContext) => {
-  const wrappedTools = {};
-  for (const [name, tool] of Object.entries(tools2)) {
-    wrappedTools[name] = {
-      ...tool,
-      execute: async (params) => {
-        const currentToolCallId = ++streamingContext.toolCallId;
-        const startedAt = Date.now();
-        if (streamingContext.controller && streamingContext.encoder) {
-          streamingContext.controller.enqueue(
-            streamingContext.encoder.encode(
-              `data: ${JSON.stringify({
-                type: "tool_call",
-                toolCall: {
-                  id: currentToolCallId,
-                  name,
-                  parameters: params,
-                  timestamp: /* @__PURE__ */ new Date(),
-                  status: "executing"
-                }
-              })}
-
-`
-            )
-          );
-        }
-        dbg("Tool executing", { name, currentToolCallId, params });
-        try {
-          const result = await tool.execute(params);
-          dbg("Tool result", {
-            name,
-            currentToolCallId,
-            ms: Date.now() - startedAt
-          });
-          if (streamingContext.controller && streamingContext.encoder) {
-            streamingContext.controller.enqueue(
-              streamingContext.encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "tool_result",
-                  toolResult: {
-                    id: currentToolCallId,
-                    toolCallId: currentToolCallId,
-                    result,
-                    timestamp: /* @__PURE__ */ new Date()
-                  }
-                })}
 
-`
-              )
-            );
-          }
-          return result;
-        } catch (error) {
-          dbg("Tool error", {
-            name,
-            currentToolCallId,
-            error: error instanceof Error ? error.message : String(error)
-          });
-          if (streamingContext.controller && streamingContext.encoder) {
-            streamingContext.controller.enqueue(
-              streamingContext.encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "tool_result",
-                  toolResult: {
-                    id: currentToolCallId,
-                    toolCallId: currentToolCallId,
-                    error: error instanceof Error ? error.message : String(error),
-                    timestamp: /* @__PURE__ */ new Date()
-                  }
-                })}
+// routes/mcp/chat.ts
+var DEBUG_ENABLED = process.env.MCP_DEBUG !== "false";
+var ELICITATION_TIMEOUT = 3e5;
+var MAX_AGENT_STEPS = 10;
+var dbg = (...args) => {
+  if (DEBUG_ENABLED) console.log("[mcp/chat]", ...args);
+};
+try {
+  process.setMaxListeners?.(50);
+} catch {
+}
+var chat = new Hono6();
+var sendSseEvent = (controller, encoder, event) => {
+  const payload = event === "[DONE]" ? "[DONE]" : JSON.stringify(event);
+  controller.enqueue(encoder.encode(`data: ${payload}
 
-`
-              )
-            );
-          }
-          throw error;
-        }
-      }
-    };
-  }
-  return wrappedTools;
+`));
 };
-var handleAgentStepFinish = (streamingContext, text, toolCalls, toolResults) => {
+var handleAgentStepFinish = (streamingContext, text2, toolCalls, toolResults) => {
   try {
     if (toolCalls && Array.isArray(toolCalls)) {
       for (const call of toolCalls) {
         const currentToolCallId = ++streamingContext.toolCallId;
         streamingContext.lastEmittedToolCallId = currentToolCallId;
         if (streamingContext.controller && streamingContext.encoder) {
-          streamingContext.controller.enqueue(
-            streamingContext.encoder.encode(
-              `data: ${JSON.stringify({
-                type: "tool_call",
-                toolCall: {
-                  id: currentToolCallId,
-                  name: call.name || call.toolName,
-                  parameters: call.params || call.args || {},
-                  timestamp: /* @__PURE__ */ new Date(),
-                  status: "executing"
-                }
-              })}
-
-`
-            )
-          );
+          sendSseEvent(streamingContext.controller, streamingContext.encoder, {
+            type: "tool_call",
+            toolCall: {
+              id: currentToolCallId,
+              name: call.name || call.toolName,
+              parameters: call.params || call.args || {},
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              status: "executing"
+            }
+          });
         }
       }
     }
@@ -717,47 +3179,35 @@ var handleAgentStepFinish = (streamingContext, text, toolCalls, toolResults) =>
       for (const result of toolResults) {
         const currentToolCallId = streamingContext.lastEmittedToolCallId != null ? streamingContext.lastEmittedToolCallId : ++streamingContext.toolCallId;
         if (streamingContext.controller && streamingContext.encoder) {
-          streamingContext.controller.enqueue(
-            streamingContext.encoder.encode(
-              `data: ${JSON.stringify({
-                type: "tool_result",
-                toolResult: {
-                  id: currentToolCallId,
-                  toolCallId: currentToolCallId,
-                  result: result.result,
-                  error: result.error,
-                  timestamp: /* @__PURE__ */ new Date()
-                }
-              })}
-
-`
-            )
-          );
+          sendSseEvent(streamingContext.controller, streamingContext.encoder, {
+            type: "tool_result",
+            toolResult: {
+              id: currentToolCallId,
+              toolCallId: currentToolCallId,
+              result: result.result,
+              error: result.error,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
         }
       }
     }
     streamingContext.stepIndex = (streamingContext.stepIndex || 0) + 1;
     if (streamingContext.controller && streamingContext.encoder) {
-      streamingContext.controller.enqueue(
-        streamingContext.encoder.encode(
-          `data: ${JSON.stringify({
-            type: "trace_step",
-            step: streamingContext.stepIndex,
-            text,
-            toolCalls: (toolCalls || []).map((c) => ({
-              name: c.name || c.toolName,
-              params: c.params || c.args || {}
-            })),
-            toolResults: (toolResults || []).map((r) => ({
-              result: r.result,
-              error: r.error
-            })),
-            timestamp: /* @__PURE__ */ new Date()
-          })}
-
-`
-        )
-      );
+      sendSseEvent(streamingContext.controller, streamingContext.encoder, {
+        type: "trace_step",
+        step: streamingContext.stepIndex,
+        text: text2,
+        toolCalls: (toolCalls || []).map((c) => ({
+          name: c.name || c.toolName,
+          params: c.params || c.args || {}
+        })),
+        toolResults: (toolResults || []).map((r) => ({
+          result: r.result,
+          error: r.error
+        })),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
     }
   } catch (err) {
     dbg("onStepFinish error", err);
@@ -766,17 +3216,48 @@ var handleAgentStepFinish = (streamingContext, text, toolCalls, toolResults) =>
 var streamAgentResponse = async (streamingContext, stream) => {
   let hasContent = false;
   let chunkCount = 0;
-  for await (const chunk of stream.textStream) {
-    if (chunk && chunk.trim()) {
+  for await (const chunk of stream.fullStream) {
+    chunkCount++;
+    if (chunk.type === "text-delta" && chunk.textDelta) {
       hasContent = true;
-      chunkCount++;
-      streamingContext.controller.enqueue(
-        streamingContext.encoder.encode(
-          `data: ${JSON.stringify({ type: "text", content: chunk })}
-
-`
-        )
-      );
+      sendSseEvent(streamingContext.controller, streamingContext.encoder, {
+        type: "text",
+        content: chunk.textDelta
+      });
+    }
+    if (chunk.type === "tool-call" && chunk.toolName) {
+      const currentToolCallId = ++streamingContext.toolCallId;
+      sendSseEvent(streamingContext.controller, streamingContext.encoder, {
+        type: "tool_call",
+        toolCall: {
+          id: currentToolCallId,
+          name: chunk.toolName,
+          parameters: chunk.args || {},
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "executing"
+        }
+      });
+    }
+    if (chunk.type === "tool-result" && chunk.result !== void 0) {
+      const currentToolCallId = streamingContext.toolCallId;
+      sendSseEvent(streamingContext.controller, streamingContext.encoder, {
+        type: "tool_result",
+        toolResult: {
+          id: currentToolCallId,
+          toolCallId: currentToolCallId,
+          result: chunk.result,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+    }
+    if (chunk.type === "error" && chunk.error) {
+      sendSseEvent(streamingContext.controller, streamingContext.encoder, {
+        type: "error",
+        error: chunk.error instanceof Error ? chunk.error.message : String(chunk.error)
+      });
+    }
+    if (chunk.type === "finish") {
+      break;
     }
   }
   dbg("Streaming finished", { hasContent, chunkCount });
@@ -787,44 +3268,54 @@ var fallbackToCompletion = async (agent, messages, streamingContext, provider, t
     const result = await agent.generate(messages, {
       temperature: temperature == null || void 0 ? getDefaultTemperatureByProvider(provider) : temperature
     });
+    console.log("result", result);
     if (result.text && result.text.trim()) {
-      streamingContext.controller.enqueue(
-        streamingContext.encoder.encode(
-          `data: ${JSON.stringify({
-            type: "text",
-            content: result.text
-          })}
-
-`
-        )
-      );
+      sendSseEvent(streamingContext.controller, streamingContext.encoder, {
+        type: "text",
+        content: result.text
+      });
     }
   } catch (fallbackErr) {
-    streamingContext.controller.enqueue(
-      streamingContext.encoder.encode(
-        `data: ${JSON.stringify({
-          type: "text",
-          content: "Failed to generate response. Please try again. ",
-          error: fallbackErr instanceof Error ? fallbackErr.message : "Unknown error"
-        })}
-
-`
-      )
-    );
+    sendSseEvent(streamingContext.controller, streamingContext.encoder, {
+      type: "error",
+      error: fallbackErr instanceof Error ? fallbackErr.message : "Unknown error"
+    });
   }
 };
-var createStreamingResponse = async (agent, messages, toolsets, streamingContext, provider, temperature) => {
-  const stream = await agent.stream(messages, {
-    maxSteps: MAX_AGENT_STEPS,
-    temperature: temperature == null || void 0 ? getDefaultTemperatureByProvider(provider) : temperature,
-    toolsets,
-    onStepFinish: ({ text, toolCalls, toolResults }) => {
-      handleAgentStepFinish(streamingContext, text, toolCalls, toolResults);
+var fallbackToStreamV1Method = async (agent, messages, streamingContext, provider, temperature) => {
+  try {
+    const stream = await agent.stream(messages, {
+      maxSteps: MAX_AGENT_STEPS,
+      temperature: temperature == null || void 0 ? getDefaultTemperatureByProvider(provider) : temperature,
+      onStepFinish: ({ text: text2, toolCalls, toolResults }) => {
+        handleAgentStepFinish(streamingContext, text2, toolCalls, toolResults);
+      }
+    });
+    let hasContent = false;
+    let chunkCount = 0;
+    for await (const chunk of stream.textStream) {
+      if (chunk && chunk.trim()) {
+        hasContent = true;
+        chunkCount++;
+        sendSseEvent(streamingContext.controller, streamingContext.encoder, {
+          type: "text",
+          content: chunk
+        });
+      }
     }
-  });
-  const { hasContent } = await streamAgentResponse(streamingContext, stream);
-  if (!hasContent) {
-    dbg("No content from textStream; falling back to completion");
+    dbg("Stream method finished", { hasContent, chunkCount });
+    if (!hasContent) {
+      dbg("No content from textStream; falling back to completion");
+      await fallbackToCompletion(
+        agent,
+        messages,
+        streamingContext,
+        provider,
+        temperature
+      );
+    }
+  } catch (streamErr) {
+    dbg("Stream method failed", streamErr);
     await fallbackToCompletion(
       agent,
       messages,
@@ -833,19 +3324,52 @@ var createStreamingResponse = async (agent, messages, toolsets, streamingContext
       temperature
     );
   }
-  streamingContext.controller.enqueue(
-    streamingContext.encoder.encode(
-      `data: ${JSON.stringify({
-        type: "elicitation_complete"
-      })}
-
-`
-    )
-  );
-  streamingContext.controller.enqueue(
-    streamingContext.encoder.encode(`data: [DONE]
-
-`)
+};
+var createStreamingResponse = async (agent, messages, streamingContext, provider, temperature) => {
+  try {
+    const stream = await agent.streamVNext(messages, {
+      stopWhen: stepCountIs(MAX_AGENT_STEPS),
+      modelSettings: {
+        temperature: temperature == null || void 0 ? getDefaultTemperatureByProvider(provider) : temperature
+      },
+      onStepFinish: ({ text: text2, toolCalls, toolResults }) => {
+        handleAgentStepFinish(streamingContext, text2, toolCalls, toolResults);
+      }
+    });
+    const { hasContent } = await streamAgentResponse(streamingContext, stream);
+    if (!hasContent) {
+      dbg("No content from fullStream; falling back to completion");
+      await fallbackToCompletion(
+        agent,
+        messages,
+        streamingContext,
+        provider,
+        temperature
+      );
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("V1 models are not supported for streamVNext")) {
+      dbg(
+        "streamVNext not supported for this model, falling back to stream method"
+      );
+      await fallbackToStreamV1Method(
+        agent,
+        messages,
+        streamingContext,
+        provider,
+        temperature
+      );
+    } else {
+      throw error;
+    }
+  }
+  sendSseEvent(streamingContext.controller, streamingContext.encoder, {
+    type: "elicitation_complete"
+  });
+  sendSseEvent(
+    streamingContext.controller,
+    streamingContext.encoder,
+    "[DONE]"
   );
 };
 chat.post("/", async (c) => {
@@ -853,7 +3377,6 @@ chat.post("/", async (c) => {
   try {
     const requestData = await c.req.json();
     const {
-      serverConfigs,
       model,
       provider,
       apiKey,
@@ -875,8 +3398,11 @@ chat.post("/", async (c) => {
           400
         );
       }
-      const pending = pendingElicitations2.get(requestId);
-      if (!pending) {
+      const success = mcpClientManager.respondToElicitation(
+        requestId,
+        response
+      );
+      if (!success) {
         return c.json(
           {
             success: false,
@@ -885,8 +3411,6 @@ chat.post("/", async (c) => {
           404
         );
       }
-      pending.resolve(response);
-      pendingElicitations2.delete(requestId);
       return c.json({ success: true });
     }
     if (!model?.id || !apiKey || !messages) {
@@ -898,80 +3422,15 @@ chat.post("/", async (c) => {
         400
       );
     }
-    if (!serverConfigs || Object.keys(serverConfigs).length === 0) {
-      return c.json(
-        {
-          success: false,
-          error: "No server configs provided"
-        },
-        400
-      );
-    }
-    const serverErrors = {};
-    const connectedServers = [];
-    for (const [serverName, serverConfig] of Object.entries(serverConfigs)) {
-      try {
-        await mcpClientManager.connectToServer(serverName, serverConfig);
-        connectedServers.push(serverName);
-        dbg("Connected to server", { serverName });
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        serverErrors[serverName] = errorMessage;
-        dbg("Failed to connect to server", { serverName, error: errorMessage });
-      }
-    }
-    if (connectedServers.length === 0) {
-      return c.json(
-        {
-          success: false,
-          error: "Failed to connect to any servers",
-          details: serverErrors
-        },
-        400
-      );
-    }
-    if (Object.keys(serverErrors).length > 0) {
-      dbg("Some servers failed to connect", {
-        connectedServers,
-        failedServers: Object.keys(serverErrors),
-        errors: serverErrors
-      });
-    }
     const llmModel = createLlmModel(model, apiKey, ollamaBaseUrl);
+    const toolsets = await mcpClientManager.getFlattenedToolsetsForEnabledServers();
     const agent = new Agent({
       name: "MCP Chat Agent",
       instructions: systemPrompt || "You are a helpful assistant with access to MCP tools.",
       model: llmModel,
-      tools: void 0
-      // Start without tools, add them in streaming context
-    });
-    const formattedMessages = messages.map((msg) => ({
-      role: msg.role,
-      content: msg.content
-    }));
-    const allTools = mcpClientManager.getAvailableTools();
-    const toolsByServer = {};
-    for (const tool of allTools) {
-      if (!toolsByServer[tool.serverId]) {
-        toolsByServer[tool.serverId] = {};
-      }
-      toolsByServer[tool.serverId][tool.name] = {
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        execute: async (params) => {
-          return await mcpClientManager.executeToolDirect(
-            `${tool.serverId}:${tool.name}`,
-            params
-          );
-        }
-      };
-    }
-    dbg("Streaming start", {
-      connectedServers,
-      toolCount: allTools.length,
-      messageCount: formattedMessages.length
+      tools: toolsets
     });
-    const encoder = new TextEncoder3();
+    const encoder = new TextEncoder2();
     const readableStream = new ReadableStream({
       async start(controller) {
         const streamingContext = {
@@ -981,70 +3440,53 @@ chat.post("/", async (c) => {
           lastEmittedToolCallId: null,
           stepIndex: 0
         };
-        const flattenedTools = {};
-        Object.values(toolsByServer).forEach((serverTools) => {
-          Object.assign(flattenedTools, serverTools);
-        });
-        const streamingWrappedTools = wrapToolsWithStreaming(
-          flattenedTools,
-          streamingContext
-        );
-        const streamingAgent = new Agent({
-          name: agent.name,
-          instructions: agent.instructions,
-          model: agent.model,
-          tools: Object.keys(streamingWrappedTools).length > 0 ? streamingWrappedTools : void 0
-        });
         mcpClientManager.setElicitationCallback(async (request) => {
           const elicitationRequest = {
             message: request.message,
             requestedSchema: request.schema
           };
           if (streamingContext.controller && streamingContext.encoder) {
-            streamingContext.controller.enqueue(
-              streamingContext.encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "elicitation_request",
-                  requestId: request.requestId,
-                  message: elicitationRequest.message,
-                  schema: elicitationRequest.requestedSchema,
-                  timestamp: /* @__PURE__ */ new Date()
-                })}
-
-`
-              )
+            sendSseEvent(
+              streamingContext.controller,
+              streamingContext.encoder,
+              {
+                type: "elicitation_request",
+                requestId: request.requestId,
+                message: elicitationRequest.message,
+                schema: elicitationRequest.requestedSchema,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              }
             );
           }
           return new Promise((resolve, reject) => {
-            pendingElicitations2.set(request.requestId, { resolve, reject });
-            setTimeout(() => {
-              if (pendingElicitations2.has(request.requestId)) {
-                pendingElicitations2.delete(request.requestId);
-                reject(new Error("Elicitation timeout"));
-              }
+            const timeout = setTimeout(() => {
+              reject(new Error("Elicitation timeout"));
             }, ELICITATION_TIMEOUT);
+            mcpClientManager.getPendingElicitations().set(request.requestId, {
+              resolve: (response2) => {
+                clearTimeout(timeout);
+                resolve(response2);
+              },
+              reject: (error) => {
+                clearTimeout(timeout);
+                reject(error);
+              }
+            });
           });
         });
         try {
           await createStreamingResponse(
-            streamingAgent,
-            formattedMessages,
-            toolsByServer,
+            agent,
+            messages,
             streamingContext,
             provider,
             temperature
           );
         } catch (error) {
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({
-                type: "error",
-                error: error instanceof Error ? error.message : "Unknown error"
-              })}
-
-`
-            )
-          );
+          sendSseEvent(controller, encoder, {
+            type: "error",
+            error: error instanceof Error ? error.message : "Unknown error"
+          });
         } finally {
           mcpClientManager.clearElicitationCallback();
           controller.close();
@@ -1327,12 +3769,12 @@ tests.post("/run-all", async (c) => {
             try {
               let serverConfigs = {};
               if (test.selectedServers && test.selectedServers.length > 0) {
-                for (const name of test.selectedServers) {
-                  if (allServers[name]) serverConfigs[name] = allServers[name];
+                for (const name17 of test.selectedServers) {
+                  if (allServers[name17]) serverConfigs[name17] = allServers[name17];
                 }
               } else {
-                for (const [name, cfg] of Object.entries(allServers)) {
-                  serverConfigs[name] = cfg;
+                for (const [name17, cfg] of Object.entries(allServers)) {
+                  serverConfigs[name17] = cfg;
                 }
               }
               const validation = validateMultipleServerConfigs(serverConfigs);
@@ -1352,37 +3794,37 @@ tests.post("/run-all", async (c) => {
                 model
               });
               const toolsets = await client.getToolsets();
-              const stream = await agent.stream(
+              const stream = await agent.streamVNext(
                 [{ role: "user", content: test.prompt || "" }],
                 {
                   maxSteps: 10,
-                  toolsets,
-                  onStepFinish: ({ text, toolCalls, toolResults }) => {
-                    step += 1;
-                    (toolCalls || []).forEach((c2) => {
-                      const toolName = c2?.name || c2?.toolName;
-                      if (toolName) {
-                        calledTools.add(toolName);
-                      }
-                    });
-                    controller.enqueue(
-                      encoder.encode(
-                        `data: ${JSON.stringify({
-                          type: "trace_step",
-                          testId: test.id,
-                          step,
-                          text,
-                          toolCalls,
-                          toolResults
-                        })}
+                  toolsets
+                }
+              );
+              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;
+                  controller.enqueue(
+                    encoder.encode(
+                      `data: ${JSON.stringify({
+                        type: "trace_step",
+                        testId: test.id,
+                        step,
+                        text: "Test completed",
+                        toolCalls: Array.from(calledTools),
+                        toolResults: []
+                      })}
 
 `
-                      )
-                    );
-                  }
+                    )
+                  );
                 }
-              );
-              for await (const _ of stream.textStream) {
               }
               const called = Array.from(calledTools);
               const missing = Array.from(expectedSet).filter(
@@ -1484,8 +3926,63 @@ oauth.get("/metadata", async (c) => {
 });
 var oauth_default = oauth;
 
+// routes/mcp/export.ts
+import { Hono as Hono9 } from "hono";
+import { zodToJsonSchema as zodToJsonSchema3 } from "zod-to-json-schema";
+var exporter = new Hono9();
+exporter.post("/server", async (c) => {
+  try {
+    const { serverId } = await c.req.json();
+    if (!serverId) {
+      return c.json({ error: "serverId is required" }, 400);
+    }
+    const mcp2 = c.mcpJamClientManager;
+    const status = mcp2.getConnectionStatus(serverId);
+    if (status !== "connected") {
+      return c.json({ error: `Server '${serverId}' is not connected` }, 400);
+    }
+    const flattenedTools = await mcp2.getToolsetsForServer(serverId);
+    const tools2 = [];
+    for (const [name17, tool] of Object.entries(flattenedTools)) {
+      let inputSchema = tool.inputSchema;
+      try {
+        inputSchema = zodToJsonSchema3(inputSchema);
+      } catch {
+      }
+      tools2.push({
+        name: name17,
+        description: tool.description,
+        inputSchema,
+        outputSchema: tool.outputSchema
+      });
+    }
+    const resources2 = mcp2.getResourcesForServer(serverId).map((r) => ({
+      uri: r.uri,
+      name: r.name,
+      description: r.description,
+      mimeType: r.mimeType
+    }));
+    const prompts2 = mcp2.getPromptsForServer(serverId).map((p) => ({
+      name: p.name,
+      description: p.description,
+      arguments: p.arguments
+    }));
+    return c.json({
+      serverId,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tools: tools2,
+      resources: resources2,
+      prompts: prompts2
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return c.json({ error: msg }, 500);
+  }
+});
+var export_default = exporter;
+
 // routes/mcp/index.ts
-var mcp = new Hono9();
+var mcp = new Hono10();
 mcp.get("/health", (c) => {
   return c.json({
     service: "MCP API",
@@ -1501,6 +3998,7 @@ mcp.route("/tests", tests_default);
 mcp.route("/resources", resources_default);
 mcp.route("/prompts", prompts_default);
 mcp.route("/oauth", oauth_default);
+mcp.route("/export", export_default);
 var mcp_default = mcp;
 
 // services/mcpjam-client-manager.ts
@@ -1526,24 +4024,49 @@ var MCPJamClientManager = class {
   pendingElicitations = /* @__PURE__ */ new Map();
   // Optional callback for handling elicitation requests
   elicitationCallback;
-  // Helper method to get unique ID for a server name
-  getServerUniqueId(serverName) {
-    return this.serverIdMapping.get(serverName);
+  // Centralized server ID resolution - handles both original names and unique IDs
+  resolveServerId(serverIdentifier) {
+    if (this.mcpClients.has(serverIdentifier)) {
+      return serverIdentifier;
+    }
+    return this.serverIdMapping.get(serverIdentifier);
   }
   // Public method to get server ID for external use (like frontend)
   getServerIdForName(serverName) {
     return this.serverIdMapping.get(serverName);
   }
-  // Public method to get original server name from a unique server ID
-  getOriginalNameForId(uniqueServerId) {
-    for (const [originalName, uid] of this.serverIdMapping.entries()) {
-      if (uid === uniqueServerId) return originalName;
+  flattenToolsets(toolsets) {
+    const flattenedTools = {};
+    Object.values(toolsets).forEach((serverTools) => {
+      Object.assign(flattenedTools, serverTools);
+    });
+    return flattenedTools;
+  }
+  async getFlattenedToolsetsForEnabledServers() {
+    const allFlattenedTools = {};
+    for (const [serverId, client] of this.mcpClients.entries()) {
+      if (this.getConnectionStatus(serverId) !== "connected") continue;
+      try {
+        const toolsets = await client.getToolsets();
+        const flattenedTools = this.flattenToolsets(toolsets);
+        Object.assign(allFlattenedTools, flattenedTools);
+      } catch (error) {
+        console.warn(`Failed to get tools from server ${serverId}:`, error);
+      }
     }
-    return void 0;
+    return allFlattenedTools;
   }
-  // Convenience: map an array of unique IDs to their original names (fallback to ID if not found)
-  mapIdsToOriginalNames(uniqueIds) {
-    return uniqueIds.map((id) => this.getOriginalNameForId(id) || id);
+  async getToolsetsForServer(serverId) {
+    const id = this.resolveServerId(serverId);
+    if (!id) {
+      throw new Error(`No MCP client available for server: ${serverId}`);
+    }
+    const client = this.mcpClients.get(id);
+    if (!client) {
+      throw new Error(`No MCP client available for server: ${serverId}`);
+    }
+    const toolsets = await client.getToolsets();
+    return this.flattenToolsets(toolsets);
   }
   async connectToServer(serverId, serverConfig) {
     const pending = this.pendingConnections.get(serverId);
@@ -1598,7 +4121,7 @@ var MCPJamClientManager = class {
     await connectPromise;
   }
   async disconnectFromServer(serverId) {
-    const id = this.getServerUniqueId(serverId);
+    const id = this.resolveServerId(serverId);
     if (!id) return;
     const client = this.mcpClients.get(id);
     if (client) {
@@ -1624,7 +4147,7 @@ var MCPJamClientManager = class {
     }
   }
   getConnectionStatus(serverId) {
-    const id = this.getServerUniqueId(serverId);
+    const id = this.resolveServerId(serverId);
     return id ? this.statuses.get(id) || "disconnected" : "disconnected";
   }
   getConnectedServers() {
@@ -1645,13 +4168,10 @@ var MCPJamClientManager = class {
     const client = this.mcpClients.get(serverId);
     if (!client) return;
     const toolsets = await client.getToolsets();
-    const flattenedTools = {};
-    Object.values(toolsets).forEach((serverTools) => {
-      Object.assign(flattenedTools, serverTools);
-    });
-    for (const [name, tool] of Object.entries(flattenedTools)) {
-      this.toolRegistry.set(`${serverId}:${name}`, {
-        name,
+    const flattenedTools = this.flattenToolsets(toolsets);
+    for (const [name17, tool] of Object.entries(flattenedTools)) {
+      this.toolRegistry.set(`${serverId}:${name17}`, {
+        name: name17,
         description: tool.description,
         inputSchema: tool.inputSchema,
         outputSchema: tool.outputSchema,
@@ -1691,27 +4211,11 @@ var MCPJamClientManager = class {
   getAvailableTools() {
     return Array.from(this.toolRegistry.values());
   }
-  async getToolsetsForServer(serverId) {
-    const id = this.getServerUniqueId(serverId);
-    if (!id) {
-      throw new Error(`No MCP client available for server: ${serverId}`);
-    }
-    const client = this.mcpClients.get(id);
-    if (!client) {
-      throw new Error(`No MCP client available for server: ${serverId}`);
-    }
-    const toolsets = await client.getToolsets();
-    const flattenedTools = {};
-    Object.values(toolsets).forEach((serverTools) => {
-      Object.assign(flattenedTools, serverTools);
-    });
-    return flattenedTools;
-  }
   getAvailableResources() {
     return Array.from(this.resourceRegistry.values());
   }
   getResourcesForServer(serverId) {
-    const id = this.getServerUniqueId(serverId);
+    const id = this.resolveServerId(serverId);
     if (!id) return [];
     return Array.from(this.resourceRegistry.values()).filter(
       (r) => r.serverId === id
@@ -1721,7 +4225,7 @@ var MCPJamClientManager = class {
     return Array.from(this.promptRegistry.values());
   }
   getPromptsForServer(serverId) {
-    const id = this.getServerUniqueId(serverId);
+    const id = this.resolveServerId(serverId);
     if (!id) return [];
     return Array.from(this.promptRegistry.values()).filter(
       (p) => p.serverId === id
@@ -1729,17 +4233,16 @@ var MCPJamClientManager = class {
   }
   async executeToolDirect(toolName, parameters = {}) {
     let serverId = "";
-    let name = toolName;
+    let name17 = toolName;
     if (toolName.includes(":")) {
       const [sid, n] = toolName.split(":", 2);
-      const mappedId = this.getServerUniqueId(sid);
-      serverId = mappedId || (this.mcpClients.has(sid) ? sid : "");
-      name = n;
+      serverId = this.resolveServerId(sid) || "";
+      name17 = n;
     } else {
       for (const tool2 of this.toolRegistry.values()) {
         if (tool2.name === toolName) {
           serverId = tool2.serverId;
-          name = toolName;
+          name17 = toolName;
           break;
         }
       }
@@ -1748,13 +4251,10 @@ var MCPJamClientManager = class {
       for (const [clientServerId, client2] of this.mcpClients.entries()) {
         try {
           const toolsets2 = await client2.getToolsets();
-          const flattenedTools2 = {};
-          Object.values(toolsets2).forEach((serverTools) => {
-            Object.assign(flattenedTools2, serverTools);
-          });
+          const flattenedTools2 = this.flattenToolsets(toolsets2);
           if (flattenedTools2[toolName]) {
             serverId = clientServerId;
-            name = toolName;
+            name17 = toolName;
             break;
           }
         } catch {
@@ -1768,13 +4268,10 @@ var MCPJamClientManager = class {
     if (!client)
       throw new Error(`No MCP client available for server: ${serverId}`);
     const toolsets = await client.getToolsets();
-    const flattenedTools = {};
-    Object.values(toolsets).forEach((serverTools) => {
-      Object.assign(flattenedTools, serverTools);
-    });
-    const tool = flattenedTools[name];
+    const flattenedTools = this.flattenToolsets(toolsets);
+    const tool = flattenedTools[name17];
     if (!tool)
-      throw new Error(`Tool '${name}' not found in server '${serverId}'`);
+      throw new Error(`Tool '${name17}' not found in server '${serverId}'`);
     const schema = tool.inputSchema;
     const hasContextProperty = schema && typeof schema === "object" && schema.properties && Object.prototype.hasOwnProperty.call(
       schema.properties,
@@ -1801,8 +4298,7 @@ var MCPJamClientManager = class {
   }
   async getResource(resourceUri, serverId) {
     let uri = resourceUri;
-    const mappedId = this.getServerUniqueId(serverId);
-    const resolvedServerId = mappedId || (this.mcpClients.has(serverId) ? serverId : void 0);
+    const resolvedServerId = this.resolveServerId(serverId);
     if (!resolvedServerId) {
       throw new Error(`No MCP client available for server: ${serverId}`);
     }
@@ -1812,8 +4308,7 @@ var MCPJamClientManager = class {
     return { contents: content?.contents || [] };
   }
   async getPrompt(promptName, serverId, args) {
-    const mappedId = this.getServerUniqueId(serverId);
-    const resolvedServerId = mappedId || (this.mcpClients.has(serverId) ? serverId : void 0);
+    const resolvedServerId = this.resolveServerId(serverId);
     if (!resolvedServerId) {
       throw new Error(`No MCP client available for server: ${serverId}`);
     }
@@ -1902,6 +4397,39 @@ function logBox(content, title) {
   console.log("\u2514" + "\u2500".repeat(width) + "\u2518");
 }
 function getMCPConfigFromEnv() {
+  const configData = process.env.MCP_CONFIG_DATA;
+  if (configData) {
+    try {
+      const config = JSON.parse(configData);
+      console.log("Parsed config data:", config);
+      if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
+        const servers2 = Object.entries(config.mcpServers).map(
+          ([name17, serverConfig]) => ({
+            name: name17,
+            type: serverConfig.type || "stdio",
+            // Default to stdio if not specified
+            command: serverConfig.command,
+            args: serverConfig.args || [],
+            env: serverConfig.env || {},
+            url: serverConfig.url
+            // For SSE/HTTP connections
+          })
+        );
+        console.log("Transformed servers:", servers2);
+        const autoConnectServer = process.env.MCP_AUTO_CONNECT_SERVER;
+        console.log(
+          "Auto-connect server filter:",
+          autoConnectServer || "none (connect to all)"
+        );
+        return {
+          servers: servers2,
+          autoConnectServer: autoConnectServer || null
+        };
+      }
+    } catch (error) {
+      console.error("Failed to parse MCP_CONFIG_DATA:", error);
+    }
+  }
   const command = process.env.MCP_SERVER_COMMAND;
   if (!command) {
     return null;
@@ -1909,17 +4437,22 @@ function getMCPConfigFromEnv() {
   const argsString = process.env.MCP_SERVER_ARGS;
   const args = argsString ? JSON.parse(argsString) : [];
   return {
-    command,
-    args,
-    name: "CLI Server"
-    // Default name for CLI-provided servers
+    servers: [
+      {
+        command,
+        args,
+        name: "CLI Server",
+        // Default name for CLI-provided servers
+        env: {}
+      }
+    ]
   };
 }
 try {
   fixPath();
 } catch {
 }
-var app = new Hono10();
+var app = new Hono11();
 var mcpJamClientManager = new MCPJamClientManager();
 app.use("*", async (c, next) => {
   c.mcpJamClientManager = mcpJamClientManager;
@@ -1973,7 +4506,8 @@ if (process.env.NODE_ENV === "production") {
   });
 }
 var port = parseInt(process.env.PORT || "3000");
-logBox(`http://localhost:${port}`, "\u{1F680} Inspector Launched");
+var hostname = process.env.NODE_ENV === "production" ? "127.0.0.1" : "localhost";
+logBox(`http://${hostname}:${port}`, "\u{1F680} Inspector Launched");
 var server = serve({
   fetch: app.fetch,
   port,