@meetsmore-oss/use-ai-server 1.7.0 → 1.9.0

package/dist/index.js

@@ -5,39 +5,60 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod2, isNodeMode, target) => {
+  var canCache = mod2 != null && typeof mod2 === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod2);
+    if (cached)
+      return cached;
+  }
   target = mod2 != null ? __create(__getProtoOf(mod2)) : {};
   const to = isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod2))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod2[key],
+        get: __accessProp.bind(mod2, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod2, to);
   return to;
 };
-var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
 var __commonJS = (cb, mod2) => () => (mod2 || cb((mod2 = { exports: {} }).exports, mod2), mod2.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -81212,15 +81233,29 @@ var __getProtoOf2 = Object.getPrototypeOf;
 var __defProp2 = Object.defineProperty;
 var __getOwnPropNames2 = Object.getOwnPropertyNames;
 var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+function __accessProp2(key) {
+  return this[key];
+}
+var __toESMCache_node2;
+var __toESMCache_esm2;
 var __toESM2 = (mod2, isNodeMode, target) => {
+  var canCache = mod2 != null && typeof mod2 === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node2 ??= new WeakMap : __toESMCache_esm2 ??= new WeakMap;
+    var cached = cache.get(mod2);
+    if (cached)
+      return cached;
+  }
   target = mod2 != null ? __create2(__getProtoOf2(mod2)) : {};
   const to = isNodeMode || !mod2 || !mod2.__esModule ? __defProp2(target, "default", { value: mod2, enumerable: true }) : target;
   for (let key of __getOwnPropNames2(mod2))
     if (!__hasOwnProp2.call(to, key))
       __defProp2(to, key, {
-        get: () => mod2[key],
+        get: __accessProp2.bind(mod2, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod2, to);
   return to;
 };
 var __commonJS2 = (cb, mod2) => () => (mod2 || cb((mod2 = { exports: {} }).exports, mod2), mod2.exports);
@@ -85697,6 +85732,17 @@ var ErrorCode;
   ErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
 })(ErrorCode ||= {});
 var TOOL_APPROVAL_REQUEST = "TOOL_APPROVAL_REQUEST";
+function asRecord(value) {
+  return value != null && typeof value === "object" ? value : null;
+}
+function isMcpConfirmationResponse(value) {
+  const obj = asRecord(value);
+  const metadata = obj ? asRecord(obj._use_ai_metadata) : null;
+  return !!(obj && obj._use_ai_internal === true && obj._use_ai_type === "confirmation_required" && metadata && typeof metadata.message === "string");
+}
+function isUseAIInternalResponse(value) {
+  return isMcpConfirmationResponse(value);
+}
 var export_EventType = import_core.EventType;
 
 // src/rateLimiter.ts
@@ -85873,56 +85919,6 @@ class Logger {
 }
 var logger2 = new Logger;
 
-// ../../node_modules/.bun/uuid@11.1.0/node_modules/uuid/dist/esm/stringify.js
-var byteToHex = [];
-for (let i = 0;i < 256; ++i) {
-  byteToHex.push((i + 256).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-}
-
-// ../../node_modules/.bun/uuid@11.1.0/node_modules/uuid/dist/esm/rng.js
-import { randomFillSync } from "crypto";
-var rnds8Pool = new Uint8Array(256);
-var poolPtr = rnds8Pool.length;
-function rng() {
-  if (poolPtr > rnds8Pool.length - 16) {
-    randomFillSync(rnds8Pool);
-    poolPtr = 0;
-  }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
-}
-
-// ../../node_modules/.bun/uuid@11.1.0/node_modules/uuid/dist/esm/native.js
-import { randomUUID } from "crypto";
-var native_default = { randomUUID };
-
-// ../../node_modules/.bun/uuid@11.1.0/node_modules/uuid/dist/esm/v4.js
-function v4(options, buf, offset) {
-  if (native_default.randomUUID && !buf && !options) {
-    return native_default.randomUUID();
-  }
-  options = options || {};
-  const rnds = options.random ?? options.rng?.() ?? rng();
-  if (rnds.length < 16) {
-    throw new Error("Random bytes length must be >= 16");
-  }
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-    }
-    for (let i = 0;i < 16; ++i) {
-      buf[offset + i] = rnds[i];
-    }
-    return buf;
-  }
-  return unsafeStringify(rnds);
-}
-var v4_default = v4;
 // ../../node_modules/.bun/mustache@4.2.0/node_modules/mustache/mustache.mjs
 /*!
  * mustache.js - Logic-less {{mustache}} templates with JavaScript
@@ -89293,28 +89289,55 @@ function popTraceIdForRun(runId) {
   }
   return traceId;
 }
-function _initializeLangfuse() {
-  const enabled = Boolean(process.env.LANGFUSE_PUBLIC_KEY && process.env.LANGFUSE_SECRET_KEY);
-  if (!enabled) {
-    return { enabled: false };
+function recordErrorTrace(params) {
+  if (!langfuse.enabled || !langfuse.client)
+    return;
+  try {
+    const trace2 = langfuse.client.trace({
+      id: params.runId,
+      name: "use-ai-error",
+      sessionId: params.sessionId,
+      input: { threadId: params.threadId, errorCategory: params.errorCategory },
+      output: { error: params.errorMessage },
+      metadata: {
+        errorCategory: params.errorCategory,
+        ipAddress: params.ipAddress,
+        source: "use-ai-server",
+        ...params.metadata
+      },
+      tags: ["error", params.errorCategory]
+    });
+    trace2.span({
+      name: params.errorCategory,
+      level: "ERROR",
+      statusMessage: params.errorMessage,
+      input: { threadId: params.threadId, errorCategory: params.errorCategory },
+      output: { error: params.errorMessage }
+    });
+  } catch (error) {
+    logger2.debug("Failed to record error trace in Langfuse", {
+      error: error instanceof Error ? error.message : String(error),
+      runId: params.runId
+    });
   }
-  const baseUrl = process.env.LANGFUSE_BASE_URL || "https://cloud.langfuse.com";
-  const release = process.env.LANGFUSE_RELEASE || "use-ai-test";
-  const langfuseClient = new Langfuse({
-    publicKey: process.env.LANGFUSE_PUBLIC_KEY,
-    secretKey: process.env.LANGFUSE_SECRET_KEY,
-    baseUrl,
-    release
-  });
+}
+var _tracingEnabled = false;
+function isTracingEnabled() {
+  return _tracingEnabled;
+}
+var _tracingStarted = false;
+var _spanProcessors = [];
+async function flushTracing() {
+  await Promise.all(_spanProcessors.map((p) => p.forceFlush()));
+}
+function startTracing(customProcessors = []) {
+  if (_tracingStarted)
+    return;
+  _tracingStarted = true;
+  if (!langfuse.enabled && customProcessors.length === 0)
+    return;
   try {
     const { NodeSDK } = require_src32();
-    const { LangfuseSpanProcessor } = require_dist5();
-    const langfuseSpanProcessor = new LangfuseSpanProcessor({
-      publicKey: process.env.LANGFUSE_PUBLIC_KEY,
-      secretKey: process.env.LANGFUSE_SECRET_KEY,
-      baseUrl,
-      release
-    });
     const traceIdCaptureProcessor = {
       onStart(span) {
         const runId = span.attributes?.["ai.telemetry.metadata.runId"];
@@ -89330,33 +89353,101 @@ function _initializeLangfuse() {
         return Promise.resolve();
       }
     };
-    const sdk = new NodeSDK({
-      spanProcessors: [traceIdCaptureProcessor, langfuseSpanProcessor]
-    });
+    const spanProcessors = [traceIdCaptureProcessor];
+    let langfuseSpanProcessor;
+    if (langfuse.enabled) {
+      const { LangfuseSpanProcessor } = require_dist5();
+      langfuseSpanProcessor = new LangfuseSpanProcessor({
+        publicKey: process.env.LANGFUSE_PUBLIC_KEY,
+        secretKey: process.env.LANGFUSE_SECRET_KEY,
+        baseUrl: process.env.LANGFUSE_BASE_URL || "https://cloud.langfuse.com",
+        release: process.env.LANGFUSE_RELEASE || "use-ai"
+      });
+      spanProcessors.push(langfuseSpanProcessor);
+    }
+    spanProcessors.push(...customProcessors);
+    const sdk = new NodeSDK({ spanProcessors });
     sdk.start();
-    logger2.info("Langfuse observability initialized", { baseUrl, release });
-    return {
-      enabled: true,
-      client: langfuseClient,
-      flush: async () => {
-        await langfuseSpanProcessor.forceFlush();
-        await langfuseClient.flushAsync();
-      }
-    };
+    _tracingEnabled = true;
+    _spanProcessors = spanProcessors;
+    logger2.info("OpenTelemetry tracing started", {
+      langfuseEnabled: langfuse.enabled,
+      customProcessorCount: customProcessors.length
+    });
   } catch (error) {
-    logger2.warn("Failed to initialize Langfuse OTEL. Install @langfuse/otel and @opentelemetry/sdk-node for tracing.", {
+    logger2.warn("Failed to start OpenTelemetry tracing. Install @opentelemetry/sdk-node for tracing.", {
       error: error instanceof Error ? error.message : "Unknown error"
     });
-    return {
-      enabled: true,
-      client: langfuseClient,
-      flush: async () => {
-        await langfuseClient.flushAsync();
-      }
-    };
   }
 }
+function _initializeLangfuse() {
+  const enabled = Boolean(process.env.LANGFUSE_PUBLIC_KEY && process.env.LANGFUSE_SECRET_KEY);
+  if (!enabled) {
+    return { enabled: false };
+  }
+  const baseUrl = process.env.LANGFUSE_BASE_URL || "https://cloud.langfuse.com";
+  const release = process.env.LANGFUSE_RELEASE || "use-ai";
+  const client = new Langfuse({
+    publicKey: process.env.LANGFUSE_PUBLIC_KEY,
+    secretKey: process.env.LANGFUSE_SECRET_KEY,
+    baseUrl,
+    release
+  });
+  return {
+    enabled: true,
+    client
+  };
+}
+// ../../node_modules/.bun/uuid@11.1.0/node_modules/uuid/dist/esm/native.js
+import { randomUUID } from "crypto";
+var native_default = { randomUUID };
+
+// ../../node_modules/.bun/uuid@11.1.0/node_modules/uuid/dist/esm/rng.js
+import { randomFillSync } from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
 
+// ../../node_modules/.bun/uuid@11.1.0/node_modules/uuid/dist/esm/stringify.js
+var byteToHex = [];
+for (let i = 0;i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// ../../node_modules/.bun/uuid@11.1.0/node_modules/uuid/dist/esm/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0;i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
 // src/plugins/FeedbackPlugin.ts
 class FeedbackPlugin {
   langfuseClient = null;
@@ -89446,6 +89537,30 @@ function findMatch(str, patternMap) {
   return;
 }
 
+// src/utils/toolFilters.ts
+function isRemoteTool(tool) {
+  return tool._remote !== undefined;
+}
+function isServerTool(tool) {
+  return tool._server !== undefined;
+}
+function and(...filters) {
+  return (tool) => filters.every((f) => f(tool));
+}
+function or(...filters) {
+  return (tool) => filters.some((f) => f(tool));
+}
+function not(filter) {
+  return (tool) => !filter(tool);
+}
+function createGlobFilter(patterns) {
+  return (tool) => {
+    if (patterns.length === 0)
+      return false;
+    return patterns.some((pattern) => matchesPattern(tool.name, pattern));
+  };
+}
+
 // src/mcp/RemoteMcpToolsProvider.ts
 class RemoteMcpToolsProvider {
   url;
@@ -89622,6 +89737,136 @@ class RemoteMcpToolsProvider {
     return Object.entries(headers).map(([key, value]) => `${key}: ${isDebug ? value : "*".repeat(value.length)}`).join(", ");
   }
 }
+// src/utils/toolConverter.ts
+function createClientToolExecutor(session) {
+  return async (args, { toolCallId }) => {
+    const result = await new Promise((resolve, reject) => {
+      if (session.abortController?.signal.aborted) {
+        reject(new Error("Run aborted"));
+        return;
+      }
+      session.pendingToolCalls.set(toolCallId, resolve);
+      session.abortController?.signal.addEventListener("abort", () => {
+        session.pendingToolCalls.delete(toolCallId);
+        reject(new Error("Run aborted"));
+      }, { once: true });
+    });
+    return JSON.parse(result);
+  };
+}
+// src/utils/toolAnnotations.ts
+function getToolAnnotations(tool) {
+  if (!tool) {
+    return;
+  }
+  if (tool.annotations) {
+    return tool.annotations;
+  }
+  if (isRemoteTool(tool)) {
+    return tool._remote.annotations;
+  }
+  return;
+}
+// src/agents/toolApproval.ts
+function toolNeedsApproval(toolDef) {
+  const annotations = getToolAnnotations(toolDef);
+  return annotations?.destructiveHint === true;
+}
+function waitForApproval(session, toolCallId) {
+  return new Promise((resolve, reject) => {
+    if (session.abortController?.signal.aborted) {
+      reject(new Error("Run aborted"));
+      return;
+    }
+    session.pendingToolApprovals.set(toolCallId, resolve);
+    session.abortController?.signal.addEventListener("abort", () => {
+      session.pendingToolApprovals.delete(toolCallId);
+      reject(new Error("Run aborted"));
+    }, { once: true });
+  });
+}
+function createApprovalWrapper(toolDef, session, events, actualExecutor) {
+  return async (args, options) => {
+    const annotations = getToolAnnotations(toolDef);
+    logger2.info("Tool requires approval", {
+      toolCallId: options.toolCallId,
+      toolName: toolDef.name
+    });
+    events.emit({
+      type: TOOL_APPROVAL_REQUEST,
+      toolCallId: options.toolCallId,
+      toolCallName: toolDef.name,
+      toolCallArgs: args,
+      annotations,
+      timestamp: Date.now()
+    });
+    const approvalResult = await waitForApproval(session, options.toolCallId);
+    if (approvalResult.approved) {
+      logger2.info("Tool approved by user", { toolCallId: options.toolCallId });
+      return actualExecutor(args, options);
+    } else {
+      logger2.info("Tool rejected by user", {
+        toolCallId: options.toolCallId,
+        reason: approvalResult.reason
+      });
+      return {
+        error: true,
+        message: `Tool execution denied by user: ${approvalResult.reason || "Action was rejected"}`
+      };
+    }
+  };
+}
+
+// src/mcp/mcpConfirmation.ts
+async function handleMcpConfirmation(confirmation, toolCallId, toolCallName, originalToolName, originalArgs, provider, session, events, mcpHeaders) {
+  const { message, metadata, additional_columns } = confirmation._use_ai_metadata;
+  logger2.info("[MCP] Tool returned confirmation_required", {
+    toolCallId,
+    toolCallName,
+    message,
+    originalToolName
+  });
+  events.emit({
+    type: TOOL_APPROVAL_REQUEST,
+    toolCallId,
+    toolCallName,
+    toolCallArgs: originalArgs,
+    message,
+    metadata,
+    timestamp: Date.now()
+  });
+  const approvalResult = await waitForApproval(session, toolCallId);
+  if (!approvalResult.approved) {
+    logger2.info("[MCP] Confirmation rejected by user", {
+      toolCallId,
+      reason: approvalResult.reason
+    });
+    return {
+      error: true,
+      message: `Tool execution denied by user: ${approvalResult.reason || "Action was rejected"}`
+    };
+  }
+  const phase2Args = additional_columns ? { ...originalArgs, ...additional_columns } : originalArgs;
+  logger2.info("[MCP] Confirmation approved, executing phase 2", {
+    toolCallId,
+    originalToolName
+  });
+  try {
+    const result = await provider.executeTool(originalToolName, phase2Args, mcpHeaders);
+    return result;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger2.error("[MCP] Phase 2 execution failed", {
+      toolCallId,
+      originalToolName,
+      error: errorMsg
+    });
+    return {
+      error: true,
+      message: `MCP confirmation execution failed: ${errorMsg}`
+    };
+  }
+}
 // src/runtime/detection.ts
 function detectRuntime() {
   if (typeof globalThis !== "undefined" && "Bun" in globalThis) {
@@ -89680,8 +89925,10 @@ class UseAIServer {
   plugins = [];
   messageHandlers = new Map;
   mcpEndpoints = [];
+  serverTools = [];
   clientIpTracker;
   constructor(config) {
+    startTracing(config.spanProcessors);
     this.config = {
       port: config.port ?? 8081,
       rateLimitMaxRequests: config.rateLimitMaxRequests ?? 0,
@@ -89712,6 +89959,21 @@ class UseAIServer {
         endpoints: this.mcpEndpoints.map((e) => e.getUrl())
       });
     }
+    if (config.tools) {
+      this.serverTools = Object.entries(config.tools).map(([name, toolConfig]) => ({
+        name,
+        description: toolConfig.description,
+        parameters: toolConfig.parameters,
+        annotations: toolConfig.annotations,
+        _server: {
+          execute: toolConfig.execute
+        }
+      }));
+      logger2.info("[Server Tools] Registered server tools", {
+        count: this.serverTools.length,
+        names: this.serverTools.map((t) => t.name)
+      });
+    }
     this.plugins = config.plugins ?? [];
     this.initializePlugins();
     this.runtimeAdapter = createRuntimeAdapter(config.runtime ?? "auto");
@@ -89812,6 +90074,19 @@ class UseAIServer {
             error: error instanceof Error ? error.message : "Unknown error",
             clientId
           });
+          if (message.type === "run_agent") {
+            const runAgentData = message.data;
+            const unhandledForwardedProps = runAgentData?.forwardedProps;
+            recordErrorTrace({
+              runId: runAgentData?.runId || socket.id,
+              errorCategory: "unhandled_error",
+              errorMessage: error instanceof Error ? error.message : "Unknown error",
+              sessionId: clientId,
+              threadId: runAgentData?.threadId,
+              ipAddress: session?.ipAddress,
+              metadata: { ...unhandledForwardedProps?.telemetryMetadata }
+            });
+          }
           this.sendEvent(socket, {
             type: export_EventType.RUN_ERROR,
             message: error instanceof Error ? error.message : "Unknown error",
@@ -89821,6 +90096,7 @@ class UseAIServer {
       });
       socket.on("disconnect", () => {
         logger2.info("Client disconnected", { clientId, ipAddress });
+        session.abortController?.abort();
         this.clientIpTracker.removePollingConnection(conn.id);
         for (const plugin of this.plugins) {
           plugin.onClientDisconnect?.(session);
@@ -89873,6 +90149,15 @@ class UseAIServer {
           requested: requestedAgent,
           available: availableAgents
         });
+        recordErrorTrace({
+          runId,
+          errorCategory: "agent_not_found",
+          errorMessage: `Agent "${requestedAgent}" not found`,
+          sessionId: session.clientId,
+          threadId,
+          ipAddress: session.ipAddress,
+          metadata: { requestedAgent, availableAgents, ...forwardedProps?.telemetryMetadata }
+        });
         this.sendEvent(session.socket, {
           type: export_EventType.RUN_ERROR,
           message: `Agent "${requestedAgent}" not found. Available agents: ${availableAgents.join(", ")}`,
@@ -89884,6 +90169,15 @@ class UseAIServer {
     const rateLimitCheck = this.rateLimiter.checkLimit(session.ipAddress);
     if (!rateLimitCheck.allowed) {
       const retryAfterSeconds = Math.ceil((rateLimitCheck.retryAfterMs || 0) / 1000);
+      recordErrorTrace({
+        runId,
+        errorCategory: "rate_limit_exceeded",
+        errorMessage: "Rate limit exceeded",
+        sessionId: session.clientId,
+        threadId,
+        ipAddress: session.ipAddress,
+        metadata: { retryAfterSeconds, ...forwardedProps?.telemetryMetadata }
+      });
       this.sendEvent(session.socket, {
         type: export_EventType.RUN_ERROR,
         message: `Rate limit exceeded. Please try again in ${retryAfterSeconds} seconds.`,
@@ -89900,6 +90194,7 @@ class UseAIServer {
     }
     session.threadId = threadId;
     session.currentRunId = runId;
+    session.abortController = new AbortController;
     session.currentMcpHeaders = mcpHeaders;
     const clientTools = tools.map((t) => ({
       ...t,
@@ -89909,11 +90204,12 @@ class UseAIServer {
     if (this.mcpEndpoints.length > 0) {
       mcpTools = await this.getMcpToolsForSession(session, mcpHeaders);
     }
-    session.tools = [...clientTools, ...mcpTools];
-    if (mcpTools.length > 0) {
-      logger2.debug("[MCP] Merged tools", {
+    session.tools = [...clientTools, ...mcpTools, ...this.serverTools];
+    if (mcpTools.length > 0 || this.serverTools.length > 0) {
+      logger2.debug("Merged tools", {
         clientTools: clientTools.length,
         mcpTools: mcpTools.length,
+        serverTools: this.serverTools.length,
         total: session.tools.length
       });
     }
@@ -90039,19 +90335,37 @@ ${block.text}`
     }
   }
   buildSystemPrompt(session, state) {
-    const parts = [];
-    if (state) {
-      parts.push("You are interacting with a web application. Here is the current state:");
-      parts.push("");
-      parts.push(JSON.stringify(state, null, 2));
-      parts.push("");
-      parts.push("Use the available tools to interact with and modify the UI based on user requests.");
-    }
-    return parts.length > 0 ? parts.join(`
-`) : undefined;
+    if (!state)
+      return;
+    return "You are interacting with a web application. Use the available tools to interact with and modify the UI based on user requests.";
   }
   handleToolResult(session, message) {
-    const { toolCallId, content } = message.data;
+    const { toolCallId, content, forwardedProps } = message.data;
+    const tools = forwardedProps?.tools;
+    const state = forwardedProps?.state;
+    if (tools && tools.length > 0) {
+      const existingRemoteTools = session.tools.filter(isRemoteTool);
+      const existingServerTools = session.tools.filter(isServerTool);
+      const updatedClientTools = tools.map((t) => ({
+        ...t,
+        parameters: t.parameters || { type: "object", properties: {}, required: [] }
+      }));
+      session.tools = [...updatedClientTools, ...existingRemoteTools, ...existingServerTools];
+      logger2.debug("Tools updated mid-run", {
+        clientId: session.clientId,
+        toolCount: session.tools.length,
+        clientToolCount: updatedClientTools.length,
+        mcpToolCount: existingRemoteTools.length,
+        serverToolCount: existingServerTools.length,
+        toolNames: session.tools.map((t) => t.name)
+      });
+    }
+    if (state !== undefined) {
+      session.state = state;
+      logger2.debug("State updated mid-run", {
+        clientId: session.clientId
+      });
+    }
     const resolver = session.pendingToolCalls.get(toolCallId);
     if (resolver) {
       resolver(content);
@@ -90079,6 +90393,7 @@ ${block.text}`
   }
   handleAbortRun(session, message) {
     const { runId } = message.data;
+    session.abortController?.abort();
     session.pendingToolCalls.clear();
     session.pendingToolApprovals.clear();
     session.currentRunId = undefined;
@@ -90171,6 +90486,7 @@ ${block.text}`
   async close() {
     clearInterval(this.cleanupInterval);
     this.mcpEndpoints.forEach((endpoint) => endpoint.destroy());
+    await Promise.all(Object.values(this.agents).map((agent) => agent.flushTelemetry?.()));
     await Promise.all(this.plugins.map((plugin) => plugin.close?.()));
     this.io.close();
     if (this.serverHandle) {
@@ -113489,34 +113805,113 @@ var marker142 = `vercel.ai.error.${name142}`;
 var symbol142 = Symbol.for(marker142);
 var _a142;
 _a142 = symbol142;
-// src/utils/toolConverter.ts
-function createClientToolExecutor(session) {
-  return async (args, { toolCallId }) => {
-    const result = await new Promise((resolve2) => {
-      session.pendingToolCalls.set(toolCallId, resolve2);
-    });
-    return JSON.parse(result);
-  };
-}
 
-// src/utils/toolFilters.ts
-function isRemoteTool(tool2) {
-  return tool2._remote !== undefined;
-}
-function and(...filters) {
-  return (tool2) => filters.every((f) => f(tool2));
-}
-function or(...filters) {
-  return (tool2) => filters.some((f) => f(tool2));
+// src/telemetry.ts
+var import_api4 = __toESM(require_src2(), 1);
+function startRunSpan(config2) {
+  const { runId, sessionId } = config2;
+  if (!langfuse.enabled && !isTracingEnabled()) {
+    return {
+      active: false,
+      wrap: (fn) => fn(),
+      setInput: () => {},
+      setOutput: () => {},
+      end: () => {
+        popTraceIdForRun(runId);
+      },
+      endWithError: () => {
+        popTraceIdForRun(runId);
+      },
+      popTraceId: () => popTraceIdForRun(runId),
+      recordError: () => {}
+    };
+  }
+  const parentSpan = import_api4.trace.getTracer("use-ai").startSpan("use-ai.agent.run", {
+    attributes: {
+      "ai.telemetry.functionId": "use-ai",
+      "ai.telemetry.metadata.runId": runId,
+      "ai.telemetry.metadata.sessionId": sessionId,
+      ...config2.attributes
+    }
+  });
+  const parentOtelContext = import_api4.trace.setSpan(import_api4.context.active(), parentSpan);
+  return {
+    active: true,
+    wrap(fn) {
+      return import_api4.context.with(parentOtelContext, fn);
+    },
+    setInput(value) {
+      parentSpan.setAttribute("langfuse.observation.input", typeof value === "string" ? value : JSON.stringify(value));
+    },
+    setOutput(value) {
+      parentSpan.setAttribute("langfuse.observation.output", typeof value === "string" ? value : JSON.stringify(value));
+    },
+    end() {
+      parentSpan.setStatus({ code: import_api4.SpanStatusCode.OK });
+      parentSpan.end();
+      popTraceIdForRun(runId);
+    },
+    endWithError(message) {
+      parentSpan.setStatus({ code: import_api4.SpanStatusCode.ERROR, message });
+      parentSpan.end();
+      popTraceIdForRun(runId);
+    },
+    popTraceId() {
+      return popTraceIdForRun(runId);
+    },
+    recordError(params) {
+      recordErrorTrace(params);
+    }
+  };
 }
-function not(filter2) {
-  return (tool2) => !filter2(tool2);
+async function flushTelemetry() {
+  await flushTracing();
+  await langfuse.client?.flushAsync();
 }
-function createGlobFilter(patterns) {
-  return (tool2) => {
-    if (patterns.length === 0)
-      return false;
-    return patterns.some((pattern) => matchesPattern(tool2.name, pattern));
+// src/tools/serverToolExecutor.ts
+function createServerToolExecutor(serverTool, session, events) {
+  return async (args, { toolCallId }) => {
+    logger2.info("[Server Tool] Executing", {
+      toolName: serverTool.name,
+      toolCallId
+    });
+    const context = {
+      session,
+      state: session.state,
+      runId: session.currentRunId || "",
+      toolCallId,
+      requestApproval: async ({ message, metadata }) => {
+        const approvalId = `${toolCallId}-approval-${Date.now()}`;
+        logger2.info("[Server Tool] Runtime approval requested", {
+          toolName: serverTool.name,
+          toolCallId,
+          approvalId,
+          message
+        });
+        events.emit({
+          type: TOOL_APPROVAL_REQUEST,
+          toolCallId: approvalId,
+          toolCallName: serverTool.name,
+          toolCallArgs: args,
+          timestamp: Date.now(),
+          message,
+          metadata
+        });
+        return waitForApproval(session, approvalId);
+      }
+    };
+    try {
+      const result = await serverTool._server.execute(args, context);
+      return result;
+    } catch (error40) {
+      const errorMsg = error40 instanceof Error ? error40.message : String(error40);
+      logger2.error("[Server Tool] Execution failed", {
+        toolName: serverTool.name,
+        toolCallId,
+        error: errorMsg
+      });
+      throw error40;
+    }
   };
 }
 
@@ -113566,73 +113961,21 @@ function applyCacheBreakpoints(messages, cacheBreakpoint, model) {
   }
   return result;
 }
-// src/utils/toolAnnotations.ts
-function getToolAnnotations(tool2) {
-  if (!tool2) {
-    return;
-  }
-  if (tool2.annotations) {
-    return tool2.annotations;
-  }
-  if (isRemoteTool(tool2)) {
-    return tool2._remote.annotations;
-  }
-  return;
-}
-// src/agents/toolApproval.ts
-function toolNeedsApproval(toolDef) {
-  const annotations = getToolAnnotations(toolDef);
-  return annotations?.destructiveHint === true;
-}
-function waitForApproval(session, toolCallId) {
-  return new Promise((resolve2) => {
-    session.pendingToolApprovals.set(toolCallId, resolve2);
-  });
-}
-function createApprovalWrapper(toolDef, session, events, actualExecutor) {
-  return async (args, options) => {
-    const annotations = getToolAnnotations(toolDef);
-    logger2.info("Tool requires approval", {
-      toolCallId: options.toolCallId,
-      toolName: toolDef.name
-    });
-    events.emit({
-      type: TOOL_APPROVAL_REQUEST,
-      toolCallId: options.toolCallId,
-      toolCallName: toolDef.name,
-      toolCallArgs: args,
-      annotations,
-      timestamp: Date.now()
-    });
-    const approvalResult = await waitForApproval(session, options.toolCallId);
-    if (approvalResult.approved) {
-      logger2.info("Tool approved by user", { toolCallId: options.toolCallId });
-      return actualExecutor(args, options);
-    } else {
-      logger2.info("Tool rejected by user", {
-        toolCallId: options.toolCallId,
-        reason: approvalResult.reason
-      });
-      return {
-        error: true,
-        message: `Tool execution denied by user: ${approvalResult.reason || "Action was rejected"}`
-      };
-    }
-  };
-}
 
 // src/agents/AISDKAgent.ts
 var DEFAULT_MAX_OUTPUT_TOKENS = 4096;
+var DEFAULT_MAX_STEPS = 10;
 
 class AISDKAgent {
   model;
   name;
   annotation;
-  langfuse;
   toolFilter;
   systemPrompt;
   cacheBreakpoint;
   maxOutputTokens;
+  temperature;
+  maxSteps;
   constructor(config2) {
     this.model = config2.model;
     this.name = config2.name || "ai-sdk";
@@ -113641,7 +113984,8 @@ class AISDKAgent {
     this.systemPrompt = config2.systemPrompt;
     this.cacheBreakpoint = config2.cacheBreakpoint;
     this.maxOutputTokens = config2.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS;
-    this.langfuse = langfuse;
+    this.temperature = config2.temperature;
+    this.maxSteps = config2.maxSteps ?? DEFAULT_MAX_STEPS;
   }
   getName() {
     return this.name;
@@ -113650,14 +113994,15 @@ class AISDKAgent {
     return this.annotation;
   }
   async flushTelemetry() {
-    if (this.langfuse.flush) {
-      await this.langfuse.flush();
-    }
+    await flushTelemetry();
   }
   async run(input, events) {
     const { session, runId, messages, tools, state, systemPrompt: runtimeSystemPrompt, originalInput } = input;
+    if (session.tools.length === 0 && tools.length > 0) {
+      session.tools = tools;
+    }
     const configSystemPrompt = await this.resolveSystemPrompt();
-    const systemMessages = this.buildSystemMessages(configSystemPrompt, runtimeSystemPrompt);
+    const staticSystemMessages = this.buildStaticSystemMessages(configSystemPrompt, runtimeSystemPrompt);
     events.emit({
       type: export_EventType.RUN_STARTED,
       threadId: session.threadId,
@@ -113675,6 +114020,12 @@ class AISDKAgent {
       snapshot: state,
       timestamp: Date.now()
     });
+    let streamTextStarted = false;
+    const span = startRunSpan({ runId, sessionId: session.clientId });
+    const lastUserMessage = [...messages].reverse().find((m) => m.role === "user");
+    if (lastUserMessage) {
+      span.setInput(lastUserMessage.content);
+    }
     try {
       logger2.info("Sending to AI SDK model (streaming)", {
         clientId: session.clientId,
@@ -113682,10 +114033,7 @@ class AISDKAgent {
         toolCount: tools.length
       });
       const sanitizedInputMessages = this.sanitizeMessages(messages);
-      const messagesWithSystem = [
-        ...systemMessages || [],
-        ...sanitizedInputMessages
-      ];
+      let currentMessages = [...sanitizedInputMessages];
       logger2.apiRequest({
         tools: tools.map((t) => t.name),
         messageCount: messages.length,
@@ -113693,147 +114041,187 @@ class AISDKAgent {
           role: msg.role,
           preview: typeof msg.content === "string" ? msg.content.substring(0, 80) + (msg.content.length > 80 ? "..." : "") : Array.isArray(msg.content) ? `${msg.content.length} content blocks` : "complex content"
         })),
-        systemMessages: systemMessages?.map((m) => m.content.substring(0, 80) + (m.content.length > 80 ? "..." : ""))
-      });
-      const messagesWithCache = applyCacheBreakpoints(messagesWithSystem, this.cacheBreakpoint, this.model);
-      const stream = streamText({
-        model: this.model,
-        messages: messagesWithCache,
-        tools: tools.length > 0 ? this.sanitizeToolsForAPI(this.filterTools(tools), session, events) : undefined,
-        stopWhen: stepCountIs(10),
-        maxOutputTokens: this.maxOutputTokens,
-        abortSignal: session.abortController?.signal,
-        experimental_telemetry: this.langfuse?.enabled ? {
-          isEnabled: true,
-          functionId: "use-ai",
-          metadata: {
-            sessionId: session.clientId,
-            threadId: session.threadId,
-            runId,
-            ipAddress: session.ipAddress,
-            toolCount: tools.length,
-            ...originalInput.forwardedProps?.telemetryMetadata || {}
-          }
-        } : undefined,
-        onStepFinish: ({ usage, finishReason }) => {
-          logger2.debug("Step finished", { usage, finishReason });
-        }
+        systemMessages: staticSystemMessages?.map((m) => m.content.substring(0, 80) + (m.content.length > 80 ? "..." : ""))
       });
       let messageId = null;
       let hasEmittedTextStart = false;
       let finalText = "";
       let currentStepNumber = 0;
       let hasAnyContent = false;
-      const activeToolCalls = new Map;
-      for await (const chunk of stream.fullStream) {
-        switch (chunk.type) {
-          case "start-step": {
-            events.emit({
-              type: export_EventType.STEP_STARTED,
-              stepName: `step-${currentStepNumber++}`,
-              timestamp: Date.now()
-            });
-            break;
+      let response = null;
+      const allResponseMessages = [];
+      for (let stepIteration = 0;stepIteration < this.maxSteps; stepIteration++) {
+        const currentTools = session.tools;
+        logger2.debug("Starting step iteration", {
+          stepIteration,
+          toolCount: currentTools.length,
+          toolNames: currentTools.map((t) => t.name)
+        });
+        const stateMessage = this.buildStateMessage(session.state);
+        const messagesForStep = [
+          ...staticSystemMessages || [],
+          ...stateMessage ? [stateMessage] : [],
+          ...currentMessages
+        ];
+        const messagesWithCache = applyCacheBreakpoints(messagesForStep, this.cacheBreakpoint, this.model);
+        streamTextStarted = true;
+        const createStream = () => streamText({
+          model: this.model,
+          messages: messagesWithCache,
+          tools: currentTools.length > 0 ? this.sanitizeToolsForAPI(this.filterTools(currentTools), session, events) : undefined,
+          stopWhen: stepCountIs(1),
+          maxOutputTokens: this.maxOutputTokens,
+          temperature: this.temperature,
+          abortSignal: session.abortController?.signal,
+          experimental_telemetry: span.active ? {
+            isEnabled: true,
+            functionId: "use-ai",
+            metadata: {
+              sessionId: session.clientId,
+              threadId: session.threadId,
+              runId,
+              ipAddress: session.ipAddress,
+              toolCount: currentTools.length,
+              stepIteration,
+              ...originalInput.forwardedProps?.telemetryMetadata || {}
+            }
+          } : undefined,
+          onStepFinish: ({ usage, finishReason }) => {
+            logger2.debug("Step finished", { usage, finishReason, stepIteration });
           }
-          case "text-delta": {
-            hasAnyContent = true;
-            if (!hasEmittedTextStart) {
-              messageId = v4_default();
+        });
+        const stream = span.wrap(createStream);
+        const activeToolCalls = new Map;
+        let stepHadToolCalls = false;
+        for await (const chunk of stream.fullStream) {
+          switch (chunk.type) {
+            case "start-step": {
+              events.emit({
+                type: export_EventType.STEP_STARTED,
+                stepName: `step-${currentStepNumber++}`,
+                timestamp: Date.now()
+              });
+              break;
+            }
+            case "text-delta": {
+              hasAnyContent = true;
+              if (!hasEmittedTextStart) {
+                messageId = v4_default();
+                events.emit({
+                  type: export_EventType.TEXT_MESSAGE_START,
+                  messageId,
+                  role: "assistant",
+                  timestamp: Date.now()
+                });
+                hasEmittedTextStart = true;
+              }
               events.emit({
-                type: export_EventType.TEXT_MESSAGE_START,
+                type: export_EventType.TEXT_MESSAGE_CONTENT,
                 messageId,
-                role: "assistant",
+                delta: chunk.text,
                 timestamp: Date.now()
               });
-              hasEmittedTextStart = true;
+              finalText += chunk.text;
+              break;
             }
-            events.emit({
-              type: export_EventType.TEXT_MESSAGE_CONTENT,
-              messageId,
-              delta: chunk.text,
-              timestamp: Date.now()
-            });
-            finalText += chunk.text;
-            break;
-          }
-          case "reasoning-delta": {
-            logger2.debug("Reasoning", { text: chunk.text });
-            break;
-          }
-          case "tool-input-start": {
-            hasAnyContent = true;
-            const toolDef = tools.find((t) => t.name === chunk.toolName);
-            const annotations = getToolAnnotations(toolDef);
-            const toolCallStartEvent = {
-              type: export_EventType.TOOL_CALL_START,
-              toolCallId: chunk.id,
-              toolCallName: chunk.toolName,
-              parentMessageId: messageId ?? v4_default(),
-              timestamp: Date.now()
-            };
-            if (annotations) {
-              toolCallStartEvent.annotations = annotations;
+            case "reasoning-delta": {
+              logger2.debug("Reasoning", { text: chunk.text });
+              break;
             }
-            events.emit(toolCallStartEvent);
-            activeToolCalls.set(chunk.id, { name: chunk.toolName, args: "" });
-            break;
-          }
-          case "tool-input-delta": {
-            const toolCall = activeToolCalls.get(chunk.id);
-            if (toolCall) {
-              toolCall.args += chunk.delta;
-              events.emit({
-                type: export_EventType.TOOL_CALL_ARGS,
+            case "tool-input-start": {
+              hasAnyContent = true;
+              stepHadToolCalls = true;
+              const toolDef = currentTools.find((t) => t.name === chunk.toolName);
+              const annotations = getToolAnnotations(toolDef);
+              const toolCallStartEvent = {
+                type: export_EventType.TOOL_CALL_START,
                 toolCallId: chunk.id,
-                delta: chunk.delta,
+                toolCallName: chunk.toolName,
+                parentMessageId: messageId ?? v4_default(),
                 timestamp: Date.now()
-              });
+              };
+              if (annotations) {
+                toolCallStartEvent.annotations = annotations;
+              }
+              events.emit(toolCallStartEvent);
+              activeToolCalls.set(chunk.id, { name: chunk.toolName, args: "" });
+              break;
             }
-            break;
-          }
-          case "tool-call": {
-            const toolCall = activeToolCalls.get(chunk.toolCallId);
-            const finalArgs = JSON.stringify(chunk.input);
-            if (toolCall && toolCall.args.length === 0) {
+            case "tool-input-delta": {
+              const toolCall = activeToolCalls.get(chunk.id);
+              if (toolCall) {
+                toolCall.args += chunk.delta;
+                events.emit({
+                  type: export_EventType.TOOL_CALL_ARGS,
+                  toolCallId: chunk.id,
+                  delta: chunk.delta,
+                  timestamp: Date.now()
+                });
+              }
+              break;
+            }
+            case "tool-call": {
+              stepHadToolCalls = true;
+              const toolCall = activeToolCalls.get(chunk.toolCallId);
+              const finalArgs = JSON.stringify(chunk.input);
+              if (toolCall && toolCall.args.length === 0) {
+                events.emit({
+                  type: export_EventType.TOOL_CALL_ARGS,
+                  toolCallId: chunk.toolCallId,
+                  delta: finalArgs,
+                  timestamp: Date.now()
+                });
+                toolCall.args = finalArgs;
+              }
               events.emit({
-                type: export_EventType.TOOL_CALL_ARGS,
+                type: export_EventType.TOOL_CALL_END,
                 toolCallId: chunk.toolCallId,
-                delta: finalArgs,
                 timestamp: Date.now()
               });
-              toolCall.args = finalArgs;
+              break;
+            }
+            case "tool-result": {
+              logger2.toolResult(chunk.toolName, JSON.stringify(chunk.output));
+              break;
+            }
+            case "finish-step": {
+              events.emit({
+                type: export_EventType.STEP_FINISHED,
+                stepName: `step-${currentStepNumber - 1}`,
+                timestamp: Date.now()
+              });
+              break;
+            }
+            case "error": {
+              throw chunk.error;
             }
-            events.emit({
-              type: export_EventType.TOOL_CALL_END,
-              toolCallId: chunk.toolCallId,
-              timestamp: Date.now()
-            });
-            break;
-          }
-          case "tool-result": {
-            logger2.toolResult(chunk.toolName, JSON.stringify(chunk.output));
-            break;
-          }
-          case "finish-step": {
-            events.emit({
-              type: export_EventType.STEP_FINISHED,
-              stepName: `step-${currentStepNumber - 1}`,
-              timestamp: Date.now()
-            });
-            break;
-          }
-          case "error": {
-            throw chunk.error;
           }
         }
-      }
-      if (session.abortController?.signal.aborted) {
-        events.emit({
-          type: export_EventType.RUN_ERROR,
-          message: "Run aborted by user",
-          timestamp: Date.now()
+        if (session.abortController?.signal.aborted) {
+          span.endWithError("Run aborted by user");
+          events.emit({
+            type: export_EventType.RUN_ERROR,
+            message: "Run aborted by user",
+            timestamp: Date.now()
+          });
+          return { success: false, error: "Run aborted", conversationHistory: session.conversationHistory };
+        }
+        response = await stream.response;
+        const stepMessages = this.sanitizeMessages(response.messages);
+        allResponseMessages.push(...stepMessages);
+        if (!stepHadToolCalls) {
+          logger2.debug("Step had no tool calls, finishing run", { stepIteration });
+          break;
+        }
+        currentMessages = [
+          ...currentMessages,
+          ...stepMessages
+        ];
+        logger2.debug("Continuing to next step after tool calls", {
+          stepIteration,
+          newMessageCount: currentMessages.length,
+          updatedToolCount: session.tools.length
         });
-        return { success: false, error: "Run aborted", conversationHistory: session.conversationHistory };
       }
       if (hasEmittedTextStart && messageId) {
         events.emit({
@@ -113843,6 +114231,7 @@ class AISDKAgent {
         });
       }
       if (!hasAnyContent) {
+        span.endWithError("Empty response from AI");
         events.emit({
           type: export_EventType.RUN_ERROR,
           message: "AI returned an empty response. This may be due to an ambiguous request. Please try being more specific.",
@@ -113854,23 +114243,16 @@ class AISDKAgent {
           conversationHistory: messages
         };
       }
-      const response = await stream.response;
-      const responseMessages = response.messages;
-      const firstResponseMsg = responseMessages[0];
-      const lastInputMsg = sanitizedInputMessages[sanitizedInputMessages.length - 1];
-      let includesInputMessages = false;
-      if (firstResponseMsg && lastInputMsg) {
-        const firstMsg = firstResponseMsg;
-        const lastMsg = lastInputMsg;
-        includesInputMessages = firstMsg.role === "user" && lastMsg.role === "user" && typeof firstMsg.content === "string" && typeof lastMsg.content === "string" && firstMsg.content === lastMsg.content;
-      }
-      const newMessages = includesInputMessages ? responseMessages.slice(session.conversationHistory.length) : responseMessages;
-      const sanitizedMessages = this.sanitizeMessages(newMessages);
-      session.conversationHistory.push(...sanitizedMessages);
+      if (!response) {
+        throw new Error("No response from AI SDK");
+      }
+      session.conversationHistory.push(...allResponseMessages);
       if (finalText) {
         logger2.aiResponse([finalText]);
       }
-      const traceId = popTraceIdForRun(runId);
+      span.setOutput(finalText);
+      const traceId = span.popTraceId();
+      span.end();
       events.emit({
         type: export_EventType.RUN_FINISHED,
         threadId: session.threadId,
@@ -113883,6 +114265,7 @@ class AISDKAgent {
         conversationHistory: session.conversationHistory
       };
     } catch (error40) {
+      span.endWithError(error40 instanceof Error ? error40.message : String(error40));
       logger2.error("Error calling AI SDK model", {
         error: error40 instanceof Error ? error40.message : "Unknown error",
         clientId: session.clientId
@@ -113902,6 +114285,18 @@ class AISDKAgent {
           errorCode = ErrorCode.RATE_LIMITED;
         }
       }
+      if (!streamTextStarted) {
+        const telemetryMetadata = originalInput.forwardedProps?.telemetryMetadata;
+        span.recordError({
+          runId,
+          errorCategory: "pre_stream_error",
+          errorMessage,
+          sessionId: session.clientId,
+          threadId: session.threadId,
+          ipAddress: session.ipAddress,
+          metadata: { errorCode, toolCount: tools.length, messageCount: messages.length, ...telemetryMetadata }
+        });
+      }
       events.emit({
         type: export_EventType.RUN_ERROR,
         message: errorCode,
@@ -113924,7 +114319,7 @@ class AISDKAgent {
     const result = await this.systemPrompt();
     return result || undefined;
   }
-  buildSystemMessages(configPrompt, runtimePrompt) {
+  buildStaticSystemMessages(configPrompt, runtimePrompt) {
     const messages = [];
     if (configPrompt) {
       messages.push({ role: "system", content: configPrompt });
@@ -113934,6 +114329,16 @@ class AISDKAgent {
     }
     return messages.length > 0 ? messages : undefined;
   }
+  buildStateMessage(state) {
+    if (!state)
+      return;
+    return {
+      role: "system",
+      content: `Current application state:
+
+${JSON.stringify(state, null, 2)}`
+    };
+  }
   filterTools(tools) {
     if (!this.toolFilter) {
       return tools;
@@ -113951,7 +114356,7 @@ class AISDKAgent {
     }
     return filteredTools;
   }
-  createMcpToolExecutor(remoteTool, session) {
+  createMcpToolExecutor(remoteTool, session, events) {
     return async (args, { toolCallId }) => {
       logger2.info("[MCP] Executing remote tool", {
         toolName: remoteTool.name,
@@ -113959,6 +114364,20 @@ class AISDKAgent {
       });
       try {
         const result = await remoteTool._remote.provider.executeTool(remoteTool._remote.originalName, args, session.currentMcpHeaders);
+        if (isUseAIInternalResponse(result)) {
+          switch (result._use_ai_type) {
+            case "confirmation_required":
+              if (isMcpConfirmationResponse(result)) {
+                return handleMcpConfirmation(result, toolCallId, remoteTool.name, remoteTool._remote.originalName, args, remoteTool._remote.provider, session, events, session.currentMcpHeaders);
+              }
+              break;
+            default:
+              logger2.warn("[MCP] Unknown _use_ai_type, returning as-is", {
+                toolCallId,
+                type: result._use_ai_type
+              });
+          }
+        }
         return result;
       } catch (error40) {
         const errorMsg = error40 instanceof Error ? error40.message : String(error40);
@@ -113977,7 +114396,14 @@ class AISDKAgent {
     for (const toolDef of tools) {
       const rawParams = toolDef.parameters;
       const inputSchema = rawParams && typeof rawParams === "object" ? { ...rawParams, type: rawParams.type || "object" } : { type: "object", properties: {} };
-      const baseExecutor = isRemoteTool(toolDef) ? this.createMcpToolExecutor(toolDef, session) : clientToolExecutor;
+      let baseExecutor;
+      if (isRemoteTool(toolDef)) {
+        baseExecutor = this.createMcpToolExecutor(toolDef, session, events);
+      } else if (isServerTool(toolDef)) {
+        baseExecutor = createServerToolExecutor(toolDef, session, events);
+      } else {
+        baseExecutor = clientToolExecutor;
+      }
       const execute = toolNeedsApproval(toolDef) ? createApprovalWrapper(toolDef, session, events, baseExecutor) : baseExecutor;
       toolsObject[toolDef.name] = {
         description: toolDef.description,
@@ -114055,12 +114481,1287 @@ ${val.text}`
     }
   }
 }
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/Options.js
+var ignoreOverride2 = Symbol("Let zodToJsonSchema decide on which parser to use");
+var defaultOptions2 = {
+  name: undefined,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: true,
+  rejectedAdditionalProperties: false,
+  definitionPath: "definitions",
+  target: "jsonSchema7",
+  strictUnions: false,
+  definitions: {},
+  errorMessages: false,
+  markdownDescription: false,
+  patternStrategy: "escape",
+  applyRegexFlags: false,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref",
+  openAiAnyTypeName: "OpenAiAnyType"
+};
+var getDefaultOptions2 = (options) => typeof options === "string" ? {
+  ...defaultOptions2,
+  name: options
+} : {
+  ...defaultOptions2,
+  ...options
+};
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/Refs.js
+var getRefs2 = (options) => {
+  const _options = getDefaultOptions2(options);
+  const currentPath = _options.name !== undefined ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+  return {
+    ..._options,
+    flags: { hasReferencedOpenAiAnyType: false },
+    currentPath,
+    propertyPath: undefined,
+    seen: new Map(Object.entries(_options.definitions).map(([name15, def]) => [
+      def._def,
+      {
+        def: def._def,
+        path: [..._options.basePath, _options.definitionPath, name15],
+        jsonSchema: undefined
+      }
+    ]))
+  };
+};
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
+function addErrorMessage(res, key, errorMessage, refs) {
+  if (!refs?.errorMessages)
+    return;
+  if (errorMessage) {
+    res.errorMessage = {
+      ...res.errorMessage,
+      [key]: errorMessage
+    };
+  }
+}
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+  res[key] = value;
+  addErrorMessage(res, key, errorMessage, refs);
+}
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
+var getRelativePath2 = (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("/");
+};
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
+function parseAnyDef2(refs) {
+  if (refs.target !== "openAi") {
+    return {};
+  }
+  const anyDefinitionPath = [
+    ...refs.basePath,
+    refs.definitionPath,
+    refs.openAiAnyTypeName
+  ];
+  refs.flags.hasReferencedOpenAiAnyType = true;
+  return {
+    $ref: refs.$refStrategy === "relative" ? getRelativePath2(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
+  };
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
+function parseArrayDef2(def, refs) {
+  const res = {
+    type: "array"
+  };
+  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
+    res.items = parseDef2(def.type._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items"]
+    });
+  }
+  if (def.minLength) {
+    setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
+  }
+  if (def.maxLength) {
+    setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+  }
+  if (def.exactLength) {
+    setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+    setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+  }
+  return res;
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
+function parseBigintDef2(def, refs) {
+  const res = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!def.checks)
+    return res;
+  for (const check2 of def.checks) {
+    switch (check2.kind) {
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check2.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check2.value, check2.message, refs);
+          }
+        } else {
+          if (!check2.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check2.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check2.value, check2.message, refs);
+          }
+        } else {
+          if (!check2.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check2.value, check2.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
+function parseBooleanDef2() {
+  return {
+    type: "boolean"
+  };
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
+function parseBrandedDef2(_def, refs) {
+  return parseDef2(_def.type._def, refs);
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
+var parseCatchDef2 = (def, refs) => {
+  return parseDef2(def.innerType._def, refs);
+};
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/date.js
+function parseDateDef2(def, refs, overrideDateStrategy) {
+  const strategy = overrideDateStrategy ?? refs.dateStrategy;
+  if (Array.isArray(strategy)) {
+    return {
+      anyOf: strategy.map((item, i) => parseDateDef2(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 integerDateParser2(def, refs);
+  }
+}
+var integerDateParser2 = (def, refs) => {
+  const res = {
+    type: "integer",
+    format: "unix-time"
+  };
+  if (refs.target === "openApi3") {
+    return res;
+  }
+  for (const check2 of def.checks) {
+    switch (check2.kind) {
+      case "min":
+        setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+        break;
+      case "max":
+        setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+        break;
+    }
+  }
+  return res;
+};
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
+function parseDefaultDef2(_def, refs) {
+  return {
+    ...parseDef2(_def.innerType._def, refs),
+    default: _def.defaultValue()
+  };
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
+function parseEffectsDef2(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef2(_def.schema._def, refs) : parseAnyDef2(refs);
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
+function parseEnumDef2(def) {
+  return {
+    type: "string",
+    enum: Array.from(def.values)
+  };
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
+var isJsonSchema7AllOfType2 = (type) => {
+  if ("type" in type && type.type === "string")
+    return false;
+  return "allOf" in type;
+};
+function parseIntersectionDef2(def, refs) {
+  const allOf = [
+    parseDef2(def.left._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "0"]
+    }),
+    parseDef2(def.right._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "1"]
+    })
+  ].filter((x) => !!x);
+  let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : undefined;
+  const mergedAllOf = [];
+  allOf.forEach((schema) => {
+    if (isJsonSchema7AllOfType2(schema)) {
+      mergedAllOf.push(...schema.allOf);
+      if (schema.unevaluatedProperties === undefined) {
+        unevaluatedProperties = undefined;
+      }
+    } else {
+      let nestedSchema = schema;
+      if ("additionalProperties" in schema && schema.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema;
+        nestedSchema = rest;
+      } else {
+        unevaluatedProperties = undefined;
+      }
+      mergedAllOf.push(nestedSchema);
+    }
+  });
+  return mergedAllOf.length ? {
+    allOf: mergedAllOf,
+    ...unevaluatedProperties
+  } : undefined;
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
+function parseLiteralDef2(def, refs) {
+  const parsedType4 = typeof def.value;
+  if (parsedType4 !== "bigint" && parsedType4 !== "number" && parsedType4 !== "boolean" && parsedType4 !== "string") {
+    return {
+      type: Array.isArray(def.value) ? "array" : "object"
+    };
+  }
+  if (refs.target === "openApi3") {
+    return {
+      type: parsedType4 === "bigint" ? "integer" : parsedType4,
+      enum: [def.value]
+    };
+  }
+  return {
+    type: parsedType4 === "bigint" ? "integer" : parsedType4,
+    const: def.value
+  };
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+var emojiRegex3 = undefined;
+var zodPatterns2 = {
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  emoji: () => {
+    if (emojiRegex3 === undefined) {
+      emojiRegex3 = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+    }
+    return emojiRegex3;
+  },
+  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}$/,
+  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])$/,
+  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 parseStringDef2(def, refs) {
+  const res = {
+    type: "string"
+  };
+  if (def.checks) {
+    for (const check2 of def.checks) {
+      switch (check2.kind) {
+        case "min":
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check2.value) : check2.value, check2.message, refs);
+          break;
+        case "max":
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check2.value) : check2.value, check2.message, refs);
+          break;
+        case "email":
+          switch (refs.emailStrategy) {
+            case "format:email":
+              addFormat2(res, "email", check2.message, refs);
+              break;
+            case "format:idn-email":
+              addFormat2(res, "idn-email", check2.message, refs);
+              break;
+            case "pattern:zod":
+              addPattern2(res, zodPatterns2.email, check2.message, refs);
+              break;
+          }
+          break;
+        case "url":
+          addFormat2(res, "uri", check2.message, refs);
+          break;
+        case "uuid":
+          addFormat2(res, "uuid", check2.message, refs);
+          break;
+        case "regex":
+          addPattern2(res, check2.regex, check2.message, refs);
+          break;
+        case "cuid":
+          addPattern2(res, zodPatterns2.cuid, check2.message, refs);
+          break;
+        case "cuid2":
+          addPattern2(res, zodPatterns2.cuid2, check2.message, refs);
+          break;
+        case "startsWith":
+          addPattern2(res, RegExp(`^${escapeLiteralCheckValue2(check2.value, refs)}`), check2.message, refs);
+          break;
+        case "endsWith":
+          addPattern2(res, RegExp(`${escapeLiteralCheckValue2(check2.value, refs)}$`), check2.message, refs);
+          break;
+        case "datetime":
+          addFormat2(res, "date-time", check2.message, refs);
+          break;
+        case "date":
+          addFormat2(res, "date", check2.message, refs);
+          break;
+        case "time":
+          addFormat2(res, "time", check2.message, refs);
+          break;
+        case "duration":
+          addFormat2(res, "duration", check2.message, refs);
+          break;
+        case "length":
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check2.value) : check2.value, check2.message, refs);
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check2.value) : check2.value, check2.message, refs);
+          break;
+        case "includes": {
+          addPattern2(res, RegExp(escapeLiteralCheckValue2(check2.value, refs)), check2.message, refs);
+          break;
+        }
+        case "ip": {
+          if (check2.version !== "v6") {
+            addFormat2(res, "ipv4", check2.message, refs);
+          }
+          if (check2.version !== "v4") {
+            addFormat2(res, "ipv6", check2.message, refs);
+          }
+          break;
+        }
+        case "base64url":
+          addPattern2(res, zodPatterns2.base64url, check2.message, refs);
+          break;
+        case "jwt":
+          addPattern2(res, zodPatterns2.jwt, check2.message, refs);
+          break;
+        case "cidr": {
+          if (check2.version !== "v6") {
+            addPattern2(res, zodPatterns2.ipv4Cidr, check2.message, refs);
+          }
+          if (check2.version !== "v4") {
+            addPattern2(res, zodPatterns2.ipv6Cidr, check2.message, refs);
+          }
+          break;
+        }
+        case "emoji":
+          addPattern2(res, zodPatterns2.emoji(), check2.message, refs);
+          break;
+        case "ulid": {
+          addPattern2(res, zodPatterns2.ulid, check2.message, refs);
+          break;
+        }
+        case "base64": {
+          switch (refs.base64Strategy) {
+            case "format:binary": {
+              addFormat2(res, "binary", check2.message, refs);
+              break;
+            }
+            case "contentEncoding:base64": {
+              setResponseValueAndErrors(res, "contentEncoding", "base64", check2.message, refs);
+              break;
+            }
+            case "pattern:zod": {
+              addPattern2(res, zodPatterns2.base64, check2.message, refs);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid": {
+          addPattern2(res, zodPatterns2.nanoid, check2.message, refs);
+        }
+        case "toLowerCase":
+        case "toUpperCase":
+        case "trim":
+          break;
+        default:
+          ((_) => {})(check2);
+      }
+    }
+  }
+  return res;
+}
+function escapeLiteralCheckValue2(literal2, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric2(literal2) : literal2;
+}
+var ALPHA_NUMERIC2 = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function escapeNonAlphaNumeric2(source) {
+  let result = "";
+  for (let i = 0;i < source.length; i++) {
+    if (!ALPHA_NUMERIC2.has(source[i])) {
+      result += "\\";
+    }
+    result += source[i];
+  }
+  return result;
+}
+function addFormat2(schema, value, message, refs) {
+  if (schema.format || schema.anyOf?.some((x) => x.format)) {
+    if (!schema.anyOf) {
+      schema.anyOf = [];
+    }
+    if (schema.format) {
+      schema.anyOf.push({
+        format: schema.format,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { format: schema.errorMessage.format }
+        }
+      });
+      delete schema.format;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.format;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.anyOf.push({
+      format: value,
+      ...message && refs.errorMessages && { errorMessage: { format: message } }
+    });
+  } else {
+    setResponseValueAndErrors(schema, "format", value, message, refs);
+  }
+}
+function addPattern2(schema, regex, message, refs) {
+  if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
+    if (!schema.allOf) {
+      schema.allOf = [];
+    }
+    if (schema.pattern) {
+      schema.allOf.push({
+        pattern: schema.pattern,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { pattern: schema.errorMessage.pattern }
+        }
+      });
+      delete schema.pattern;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.pattern;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.allOf.push({
+      pattern: stringifyRegExpWithFlags2(regex, refs),
+      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
+    });
+  } else {
+    setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags2(regex, refs), message, refs);
+  }
+}
+function stringifyRegExpWithFlags2(regex, refs) {
+  if (!refs.applyRegexFlags || !regex.flags) {
+    return regex.source;
+  }
+  const flags = {
+    i: regex.flags.includes("i"),
+    m: regex.flags.includes("m"),
+    s: regex.flags.includes("s")
+  };
+  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] === "-" && source[i + 2]?.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 {
+    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;
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
+function parseRecordDef2(def, refs) {
+  if (refs.target === "openAi") {
+    console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
+  }
+  if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      type: "object",
+      required: def.keyType._def.values,
+      properties: def.keyType._def.values.reduce((acc, key) => ({
+        ...acc,
+        [key]: parseDef2(def.valueType._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, "properties", key]
+        }) ?? parseAnyDef2(refs)
+      }), {}),
+      additionalProperties: refs.rejectedAdditionalProperties
+    };
+  }
+  const schema = {
+    type: "object",
+    additionalProperties: parseDef2(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    }) ?? refs.allowedAdditionalProperties
+  };
+  if (refs.target === "openApi3") {
+    return schema;
+  }
+  if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
+    const { type, ...keyType } = parseStringDef2(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values
+      }
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
+    const { type, ...keyType } = parseBrandedDef2(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  }
+  return schema;
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
+function parseMapDef2(def, refs) {
+  if (refs.mapStrategy === "record") {
+    return parseRecordDef2(def, refs);
+  }
+  const keys = parseDef2(def.keyType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "0"]
+  }) || parseAnyDef2(refs);
+  const values = parseDef2(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "1"]
+  }) || parseAnyDef2(refs);
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
+function parseNativeEnumDef2(def) {
+  const object3 = def.values;
+  const actualKeys = Object.keys(def.values).filter((key) => {
+    return typeof object3[object3[key]] !== "number";
+  });
+  const actualValues = actualKeys.map((key) => object3[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
+  };
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
+function parseNeverDef2(refs) {
+  return refs.target === "openAi" ? undefined : {
+    not: parseAnyDef2({
+      ...refs,
+      currentPath: [...refs.currentPath, "not"]
+    })
+  };
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
+function parseNullDef2(refs) {
+  return refs.target === "openApi3" ? {
+    enum: ["null"],
+    nullable: true
+  } : {
+    type: "null"
+  };
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
+var primitiveMappings2 = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null"
+};
+function parseUnionDef2(def, refs) {
+  if (refs.target === "openApi3")
+    return asAnyOf2(def, refs);
+  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+  if (options.every((x) => (x._def.typeName in primitiveMappings2) && (!x._def.checks || !x._def.checks.length))) {
+    const types2 = options.reduce((types3, x) => {
+      const type = primitiveMappings2[x._def.typeName];
+      return type && !types3.includes(type) ? [...types3, type] : types3;
+    }, []);
+    return {
+      type: types2.length > 1 ? types2 : types2[0]
+    };
+  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+    const types2 = 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 (types2.length === options.length) {
+      const uniqueTypes = types2.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 asAnyOf2(def, refs);
+}
+var asAnyOf2 = (def, refs) => {
+  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef2(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 } : undefined;
+};
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
+function parseNullableDef2(def, refs) {
+  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
+    if (refs.target === "openApi3") {
+      return {
+        type: primitiveMappings2[def.innerType._def.typeName],
+        nullable: true
+      };
+    }
+    return {
+      type: [
+        primitiveMappings2[def.innerType._def.typeName],
+        "null"
+      ]
+    };
+  }
+  if (refs.target === "openApi3") {
+    const base2 = parseDef2(def.innerType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath]
+    });
+    if (base2 && "$ref" in base2)
+      return { allOf: [base2], nullable: true };
+    return base2 && { ...base2, nullable: true };
+  }
+  const base = parseDef2(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "0"]
+  });
+  return base && { anyOf: [base, { type: "null" }] };
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/number.js
+function parseNumberDef2(def, refs) {
+  const res = {
+    type: "number"
+  };
+  if (!def.checks)
+    return res;
+  for (const check2 of def.checks) {
+    switch (check2.kind) {
+      case "int":
+        res.type = "integer";
+        addErrorMessage(res, "type", check2.message, refs);
+        break;
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check2.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check2.value, check2.message, refs);
+          }
+        } else {
+          if (!check2.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check2.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check2.value, check2.message, refs);
+          }
+        } else {
+          if (!check2.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check2.value, check2.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
+function parseObjectDef2(def, refs) {
+  const forceOptionalIntoNullable = refs.target === "openAi";
+  const result = {
+    type: "object",
+    properties: {}
+  };
+  const required2 = [];
+  const shape = def.shape();
+  for (const propName in shape) {
+    let propDef = shape[propName];
+    if (propDef === undefined || propDef._def === undefined) {
+      continue;
+    }
+    let propOptional = safeIsOptional2(propDef);
+    if (propOptional && forceOptionalIntoNullable) {
+      if (propDef._def.typeName === "ZodOptional") {
+        propDef = propDef._def.innerType;
+      }
+      if (!propDef.isNullable()) {
+        propDef = propDef.nullable();
+      }
+      propOptional = false;
+    }
+    const parsedDef = parseDef2(propDef._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "properties", propName],
+      propertyPath: [...refs.currentPath, "properties", propName]
+    });
+    if (parsedDef === undefined) {
+      continue;
+    }
+    result.properties[propName] = parsedDef;
+    if (!propOptional) {
+      required2.push(propName);
+    }
+  }
+  if (required2.length) {
+    result.required = required2;
+  }
+  const additionalProperties = decideAdditionalProperties2(def, refs);
+  if (additionalProperties !== undefined) {
+    result.additionalProperties = additionalProperties;
+  }
+  return result;
+}
+function decideAdditionalProperties2(def, refs) {
+  if (def.catchall._def.typeName !== "ZodNever") {
+    return parseDef2(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 safeIsOptional2(schema) {
+  try {
+    return schema.isOptional();
+  } catch {
+    return true;
+  }
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
+var parseOptionalDef2 = (def, refs) => {
+  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
+    return parseDef2(def.innerType._def, refs);
+  }
+  const innerSchema = parseDef2(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "1"]
+  });
+  return innerSchema ? {
+    anyOf: [
+      {
+        not: parseAnyDef2(refs)
+      },
+      innerSchema
+    ]
+  } : parseAnyDef2(refs);
+};
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
+var parsePipelineDef2 = (def, refs) => {
+  if (refs.pipeStrategy === "input") {
+    return parseDef2(def.in._def, refs);
+  } else if (refs.pipeStrategy === "output") {
+    return parseDef2(def.out._def, refs);
+  }
+  const a = parseDef2(def.in._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", "0"]
+  });
+  const b = parseDef2(def.out._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
+  });
+  return {
+    allOf: [a, b].filter((x) => x !== undefined)
+  };
+};
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
+function parsePromiseDef2(def, refs) {
+  return parseDef2(def.type._def, refs);
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
+function parseSetDef2(def, refs) {
+  const items = parseDef2(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items"]
+  });
+  const schema = {
+    type: "array",
+    uniqueItems: true,
+    items
+  };
+  if (def.minSize) {
+    setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
+  }
+  if (def.maxSize) {
+    setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+  }
+  return schema;
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
+function parseTupleDef2(def, refs) {
+  if (def.rest) {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      items: def.items.map((x, i) => parseDef2(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === undefined ? acc : [...acc, x], []),
+      additionalItems: parseDef2(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) => parseDef2(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === undefined ? acc : [...acc, x], [])
+    };
+  }
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
+function parseUndefinedDef2(refs) {
+  return {
+    not: parseAnyDef2(refs)
+  };
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
+function parseUnknownDef2(refs) {
+  return parseAnyDef2(refs);
+}
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
+var parseReadonlyDef2 = (def, refs) => {
+  return parseDef2(def.innerType._def, refs);
+};
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/selectParser.js
+var selectParser2 = (def, typeName, refs) => {
+  switch (typeName) {
+    case ZodFirstPartyTypeKind.ZodString:
+      return parseStringDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodNumber:
+      return parseNumberDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodObject:
+      return parseObjectDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodBigInt:
+      return parseBigintDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodBoolean:
+      return parseBooleanDef2();
+    case ZodFirstPartyTypeKind.ZodDate:
+      return parseDateDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodUndefined:
+      return parseUndefinedDef2(refs);
+    case ZodFirstPartyTypeKind.ZodNull:
+      return parseNullDef2(refs);
+    case ZodFirstPartyTypeKind.ZodArray:
+      return parseArrayDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodUnion:
+    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+      return parseUnionDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodIntersection:
+      return parseIntersectionDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodTuple:
+      return parseTupleDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodRecord:
+      return parseRecordDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodLiteral:
+      return parseLiteralDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodEnum:
+      return parseEnumDef2(def);
+    case ZodFirstPartyTypeKind.ZodNativeEnum:
+      return parseNativeEnumDef2(def);
+    case ZodFirstPartyTypeKind.ZodNullable:
+      return parseNullableDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodOptional:
+      return parseOptionalDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodMap:
+      return parseMapDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodSet:
+      return parseSetDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodLazy:
+      return () => def.getter()._def;
+    case ZodFirstPartyTypeKind.ZodPromise:
+      return parsePromiseDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodNaN:
+    case ZodFirstPartyTypeKind.ZodNever:
+      return parseNeverDef2(refs);
+    case ZodFirstPartyTypeKind.ZodEffects:
+      return parseEffectsDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodAny:
+      return parseAnyDef2(refs);
+    case ZodFirstPartyTypeKind.ZodUnknown:
+      return parseUnknownDef2(refs);
+    case ZodFirstPartyTypeKind.ZodDefault:
+      return parseDefaultDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodBranded:
+      return parseBrandedDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodReadonly:
+      return parseReadonlyDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodCatch:
+      return parseCatchDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodPipeline:
+      return parsePipelineDef2(def, refs);
+    case ZodFirstPartyTypeKind.ZodFunction:
+    case ZodFirstPartyTypeKind.ZodVoid:
+    case ZodFirstPartyTypeKind.ZodSymbol:
+      return;
+    default:
+      return ((_) => {
+        return;
+      })(typeName);
+  }
+};
+
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/parseDef.js
+function parseDef2(def, refs, forceResolution = false) {
+  const seenItem = refs.seen.get(def);
+  if (refs.override) {
+    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+    if (overrideResult !== ignoreOverride2) {
+      return overrideResult;
+    }
+  }
+  if (seenItem && !forceResolution) {
+    const seenSchema = get$ref2(seenItem, refs);
+    if (seenSchema !== undefined) {
+      return seenSchema;
+    }
+  }
+  const newItem = { def, path: refs.currentPath, jsonSchema: undefined };
+  refs.seen.set(def, newItem);
+  const jsonSchemaOrGetter = selectParser2(def, def.typeName, refs);
+  const jsonSchema2 = typeof jsonSchemaOrGetter === "function" ? parseDef2(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  if (jsonSchema2) {
+    addMeta2(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$ref2 = (item, refs) => {
+  switch (refs.$refStrategy) {
+    case "root":
+      return { $ref: item.path.join("/") };
+    case "relative":
+      return { $ref: getRelativePath2(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 parseAnyDef2(refs);
+      }
+      return refs.$refStrategy === "seen" ? parseAnyDef2(refs) : undefined;
+    }
+  }
+};
+var addMeta2 = (def, refs, jsonSchema2) => {
+  if (def.description) {
+    jsonSchema2.description = def.description;
+    if (refs.markdownDescription) {
+      jsonSchema2.markdownDescription = def.description;
+    }
+  }
+  return jsonSchema2;
+};
+// ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
+var zodToJsonSchema = (schema, options) => {
+  const refs = getRefs2(options);
+  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name17, schema2]) => ({
+    ...acc,
+    [name17]: parseDef2(schema2._def, {
+      ...refs,
+      currentPath: [...refs.basePath, refs.definitionPath, name17]
+    }, true) ?? parseAnyDef2(refs)
+  }), {}) : undefined;
+  const name15 = typeof options === "string" ? options : options?.nameStrategy === "title" ? undefined : options?.name;
+  const main = parseDef2(schema._def, name15 === undefined ? refs : {
+    ...refs,
+    currentPath: [...refs.basePath, refs.definitionPath, name15]
+  }, false) ?? parseAnyDef2(refs);
+  const title = typeof options === "object" && options.name !== undefined && options.nameStrategy === "title" ? options.name : undefined;
+  if (title !== undefined) {
+    main.title = title;
+  }
+  if (refs.flags.hasReferencedOpenAiAnyType) {
+    if (!definitions) {
+      definitions = {};
+    }
+    if (!definitions[refs.openAiAnyTypeName]) {
+      definitions[refs.openAiAnyTypeName] = {
+        type: ["string", "number", "integer", "boolean", "array", "null"],
+        items: {
+          $ref: refs.$refStrategy === "relative" ? "1" : [
+            ...refs.basePath,
+            refs.definitionPath,
+            refs.openAiAnyTypeName
+          ].join("/")
+        }
+      };
+    }
+  }
+  const combined = name15 === undefined ? definitions ? {
+    ...main,
+    [refs.definitionPath]: definitions
+  } : main : {
+    $ref: [
+      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
+      refs.definitionPath,
+      name15
+    ].join("/"),
+    [refs.definitionPath]: {
+      ...definitions,
+      [name15]: main
+    }
+  };
+  if (refs.target === "jsonSchema7") {
+    combined.$schema = "http://json-schema.org/draft-07/schema#";
+  } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
+    combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+  }
+  if (refs.target === "openAi" && (("anyOf" in combined) || ("oneOf" in combined) || ("allOf" in combined) || ("type" in combined) && Array.isArray(combined.type))) {
+    console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+  }
+  return combined;
+};
+// src/tools/defineServerTool.ts
+function defineServerTool(description, schemaOrExecute, executeOrOptions, options) {
+  const isNoParamForm = typeof schemaOrExecute === "function";
+  let parameters;
+  let execute;
+  let actualOptions;
+  if (isNoParamForm) {
+    parameters = { type: "object", properties: {} };
+    execute = schemaOrExecute;
+    actualOptions = executeOrOptions || {};
+  } else {
+    const schema = schemaOrExecute;
+    const jsonSchema2 = zodToJsonSchema(schema, { target: "openApi3" });
+    parameters = {
+      type: "object",
+      properties: jsonSchema2.properties || {}
+    };
+    if (jsonSchema2.required && jsonSchema2.required.length > 0) {
+      parameters.required = jsonSchema2.required;
+    }
+    execute = executeOrOptions;
+    actualOptions = options || {};
+  }
+  const config2 = {
+    description,
+    parameters,
+    execute
+  };
+  if (actualOptions.annotations) {
+    config2.annotations = actualOptions.annotations;
+  }
+  return config2;
+}
 export {
+  startRunSpan,
   or,
   not,
   logger2 as logger,
+  isUseAIInternalResponse,
+  isServerTool,
   isRemoteTool,
+  isMcpConfirmationResponse,
   getToolAnnotations,
+  flushTelemetry,
+  defineServerTool,
   createGlobFilter,
   createClientToolExecutor,
   and,