mcp-use 1.9.1-canary.1 → 1.10.0-canary.11

package/dist/src/agents/index.cjs

@@ -35,9 +35,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 async function getNodeModules() {
   if (typeof process !== "undefined" && process.platform) {
     try {
-      const fs3 = await import("fs");
-      const path3 = await import("path");
-      return { fs: fs3.default, path: path3.default };
+      const fs = await import("fs");
+      const path = await import("path");
+      return { fs: fs.default, path: path.default };
     } catch {
       return { fs: null, path: null };
     }
@@ -1055,1929 +1055,2555 @@ __export(agents_exports, {
 module.exports = __toCommonJS(agents_exports);
 
 // src/connectors/base.ts
-var import_types = require("@modelcontextprotocol/sdk/types.js");
+var import_types = require("@mcp-use/modelcontextprotocol-sdk/types.js");
 init_logging();
 
-// src/client/connectors/codeMode.ts
-var CODE_MODE_AGENT_PROMPT = `
-## MCP Code Mode Tool Usage Guide
-
-You have access to an MCP Code Mode Client that allows you to execute JavaScript/TypeScript code with access to registered tools. Follow this workflow:
-
-### 1. Tool Discovery Phase
-**Always start by discovering available tools:**
-- Tools are organized by server namespace (e.g., \`server_name.tool_name\`)
-- Use the \`search_tools(query, detail_level)\` function to find available tools
-- You can access \`__tool_namespaces\` to see all available server namespaces
-
-\`\`\`javascript
-// Find all GitHub-related tools
-const tools = await search_tools("github");
-for (const tool of tools) {
-    console.log(\`\${tool.server}.\${tool.name}: \${tool.description}\`);
+// src/telemetry/events.ts
+var BaseTelemetryEvent = class {
+  static {
+    __name(this, "BaseTelemetryEvent");
+  }
+};
+var MCPAgentExecutionEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "MCPAgentExecutionEvent");
+  }
+  get name() {
+    return "mcp_agent_execution";
+  }
+  get properties() {
+    return {
+      // Core execution info
+      execution_method: this.data.executionMethod,
+      query: this.data.query,
+      query_length: this.data.query.length,
+      success: this.data.success,
+      // Agent configuration
+      model_provider: this.data.modelProvider,
+      model_name: this.data.modelName,
+      server_count: this.data.serverCount,
+      server_identifiers: this.data.serverIdentifiers,
+      total_tools_available: this.data.totalToolsAvailable,
+      tools_available_names: this.data.toolsAvailableNames,
+      max_steps_configured: this.data.maxStepsConfigured,
+      memory_enabled: this.data.memoryEnabled,
+      use_server_manager: this.data.useServerManager,
+      // Execution parameters (always include, even if null)
+      max_steps_used: this.data.maxStepsUsed,
+      manage_connector: this.data.manageConnector,
+      external_history_used: this.data.externalHistoryUsed,
+      // Execution results (always include, even if null)
+      steps_taken: this.data.stepsTaken ?? null,
+      tools_used_count: this.data.toolsUsedCount ?? null,
+      tools_used_names: this.data.toolsUsedNames ?? null,
+      response: this.data.response ?? null,
+      response_length: this.data.response ? this.data.response.length : null,
+      execution_time_ms: this.data.executionTimeMs ?? null,
+      error_type: this.data.errorType ?? null,
+      conversation_history_length: this.data.conversationHistoryLength ?? null
+    };
+  }
+};
+function createServerRunEventData(server, transport) {
+  const toolRegistrations = Array.from(server.registrations.tools.values());
+  const promptRegistrations = Array.from(server.registrations.prompts.values());
+  const resourceRegistrations = Array.from(
+    server.registrations.resources.values()
+  );
+  const templateRegistrations = Array.from(
+    server.registrations.resourceTemplates.values()
+  );
+  const allResources = resourceRegistrations.map((r) => ({
+    name: r.config.name,
+    title: r.config.title ?? null,
+    description: r.config.description ?? null,
+    uri: r.config.uri ?? null,
+    mime_type: r.config.mimeType ?? null
+  }));
+  const appsSdkResources = allResources.filter(
+    (r) => r.mime_type === "text/html+skybridge"
+  );
+  const mcpUiResources = allResources.filter(
+    (r) => r.mime_type === "text/uri-list" || r.mime_type === "text/html"
+  );
+  const mcpAppsResources = allResources.filter(
+    (r) => r.mime_type === "text/html+mcp"
+  );
+  return {
+    transport,
+    toolsNumber: server.registeredTools.length,
+    resourcesNumber: server.registeredResources.length,
+    promptsNumber: server.registeredPrompts.length,
+    auth: !!server.oauthProvider,
+    name: server.config.name,
+    description: server.config.description ?? null,
+    baseUrl: server.serverBaseUrl ?? null,
+    toolNames: server.registeredTools.length > 0 ? server.registeredTools : null,
+    resourceNames: server.registeredResources.length > 0 ? server.registeredResources : null,
+    promptNames: server.registeredPrompts.length > 0 ? server.registeredPrompts : null,
+    tools: toolRegistrations.length > 0 ? toolRegistrations.map((r) => ({
+      name: r.config.name,
+      title: r.config.title ?? null,
+      description: r.config.description ?? null,
+      input_schema: r.config.schema ? JSON.stringify(r.config.schema) : null,
+      output_schema: r.config.outputSchema ? JSON.stringify(r.config.outputSchema) : null
+    })) : null,
+    resources: allResources.length > 0 ? allResources : null,
+    prompts: promptRegistrations.length > 0 ? promptRegistrations.map((r) => ({
+      name: r.config.name,
+      title: r.config.title ?? null,
+      description: r.config.description ?? null,
+      args: r.config.args ? JSON.stringify(r.config.args) : null
+    })) : null,
+    templates: templateRegistrations.length > 0 ? templateRegistrations.map((r) => ({
+      name: r.config.name,
+      title: r.config.title ?? null,
+      description: r.config.description ?? null
+    })) : null,
+    capabilities: {
+      logging: true,
+      resources: { subscribe: true, listChanged: true }
+    },
+    appsSdkResources: appsSdkResources.length > 0 ? appsSdkResources : null,
+    appsSdkResourcesNumber: appsSdkResources.length,
+    mcpUiResources: mcpUiResources.length > 0 ? mcpUiResources : null,
+    mcpUiResourcesNumber: mcpUiResources.length,
+    mcpAppsResources: mcpAppsResources.length > 0 ? mcpAppsResources : null,
+    mcpAppsResourcesNumber: mcpAppsResources.length
+  };
 }
+__name(createServerRunEventData, "createServerRunEventData");
+var ServerRunEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ServerRunEvent");
+  }
+  get name() {
+    return "server_run";
+  }
+  get properties() {
+    return {
+      transport: this.data.transport,
+      tools_number: this.data.toolsNumber,
+      resources_number: this.data.resourcesNumber,
+      prompts_number: this.data.promptsNumber,
+      auth: this.data.auth,
+      name: this.data.name,
+      description: this.data.description ?? null,
+      base_url: this.data.baseUrl ?? null,
+      tool_names: this.data.toolNames ?? null,
+      resource_names: this.data.resourceNames ?? null,
+      prompt_names: this.data.promptNames ?? null,
+      tools: this.data.tools ?? null,
+      resources: this.data.resources ?? null,
+      prompts: this.data.prompts ?? null,
+      templates: this.data.templates ?? null,
+      capabilities: this.data.capabilities ? JSON.stringify(this.data.capabilities) : null,
+      apps_sdk_resources: this.data.appsSdkResources ? JSON.stringify(this.data.appsSdkResources) : null,
+      apps_sdk_resources_number: this.data.appsSdkResourcesNumber ?? 0,
+      mcp_ui_resources: this.data.mcpUiResources ? JSON.stringify(this.data.mcpUiResources) : null,
+      mcp_ui_resources_number: this.data.mcpUiResourcesNumber ?? 0,
+      mcp_apps_resources: this.data.mcpAppsResources ? JSON.stringify(this.data.mcpAppsResources) : null,
+      mcp_apps_resources_number: this.data.mcpAppsResourcesNumber ?? 0
+    };
+  }
+};
+var ServerInitializeEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ServerInitializeEvent");
+  }
+  get name() {
+    return "server_initialize_call";
+  }
+  get properties() {
+    return {
+      protocol_version: this.data.protocolVersion,
+      client_info: JSON.stringify(this.data.clientInfo),
+      client_capabilities: JSON.stringify(this.data.clientCapabilities),
+      session_id: this.data.sessionId ?? null
+    };
+  }
+};
+var ServerToolCallEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ServerToolCallEvent");
+  }
+  get name() {
+    return "server_tool_call";
+  }
+  get properties() {
+    return {
+      tool_name: this.data.toolName,
+      length_input_argument: this.data.lengthInputArgument,
+      success: this.data.success,
+      error_type: this.data.errorType ?? null,
+      execution_time_ms: this.data.executionTimeMs ?? null
+    };
+  }
+};
+var ServerResourceCallEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ServerResourceCallEvent");
+  }
+  get name() {
+    return "server_resource_call";
+  }
+  get properties() {
+    return {
+      name: this.data.name,
+      description: this.data.description,
+      contents: this.data.contents,
+      success: this.data.success,
+      error_type: this.data.errorType ?? null
+    };
+  }
+};
+var ServerPromptCallEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ServerPromptCallEvent");
+  }
+  get name() {
+    return "server_prompt_call";
+  }
+  get properties() {
+    return {
+      name: this.data.name,
+      description: this.data.description,
+      success: this.data.success,
+      error_type: this.data.errorType ?? null
+    };
+  }
+};
+var ServerContextEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ServerContextEvent");
+  }
+  get name() {
+    return `server_context_${this.data.contextType}`;
+  }
+  get properties() {
+    return {
+      context_type: this.data.contextType,
+      notification_type: this.data.notificationType ?? null
+    };
+  }
+};
+var MCPClientInitEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "MCPClientInitEvent");
+  }
+  get name() {
+    return "mcpclient_init";
+  }
+  get properties() {
+    return {
+      code_mode: this.data.codeMode,
+      sandbox: this.data.sandbox,
+      all_callbacks: this.data.allCallbacks,
+      verify: this.data.verify,
+      servers: this.data.servers,
+      num_servers: this.data.numServers,
+      is_browser: this.data.isBrowser
+    };
+  }
+};
+var ConnectorInitEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ConnectorInitEvent");
+  }
+  get name() {
+    return "connector_init";
+  }
+  get properties() {
+    return {
+      connector_type: this.data.connectorType,
+      server_command: this.data.serverCommand ?? null,
+      server_args: this.data.serverArgs ?? null,
+      server_url: this.data.serverUrl ?? null,
+      public_identifier: this.data.publicIdentifier ?? null
+    };
+  }
+};
+var ClientAddServerEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ClientAddServerEvent");
+  }
+  get name() {
+    return "client_add_server";
+  }
+  get properties() {
+    const { serverName, serverConfig } = this.data;
+    const url = serverConfig.url;
+    return {
+      server_name: serverName,
+      server_url_domain: url ? this._extractHostname(url) : null,
+      transport: serverConfig.transport ?? null,
+      has_auth: !!(serverConfig.authToken || serverConfig.authProvider)
+    };
+  }
+  _extractHostname(url) {
+    try {
+      return new URL(url).hostname;
+    } catch {
+      return null;
+    }
+  }
+};
+var ClientRemoveServerEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ClientRemoveServerEvent");
+  }
+  get name() {
+    return "client_remove_server";
+  }
+  get properties() {
+    return {
+      server_name: this.data.serverName
+    };
+  }
+};
 
-// Get only tool names for quick overview
-const tools = await search_tools("", "names");
-\`\`\`
-
-### 2. Interface Introspection
-**Understand tool contracts before using them:**
-- Use \`search_tools\` to get tool descriptions and input schemas
-- Look for "Access as: server.tool(args)" patterns in descriptions
-
-### 3. Code Execution Guidelines
-**When writing code:**
-- Use \`await server.tool({ param: value })\` syntax for all tool calls
-- Tools are async functions that return promises
-- You have access to standard JavaScript globals: \`console\`, \`JSON\`, \`Math\`, \`Date\`, etc.
-- All console output (\`console.log\`, \`console.error\`, etc.) is automatically captured and returned
-- Build properly structured input objects based on interface definitions
-- Handle errors appropriately with try/catch blocks
-- Chain tool calls by using results from previous calls
-
-### 4. Best Practices
-- **Discover first, code second**: Always explore available tools before writing execution code
-- **Respect namespaces**: Use full \`server.tool\` names to avoid conflicts
-- **Minimize Context**: Process large data in code, return only essential results
-- **Error handling**: Wrap tool calls in try/catch for robustness
-- **Data flow**: Chain tools by passing outputs as inputs to subsequent tools
-
-### 5. Available Runtime Context
-- \`search_tools(query, detail_level)\`: Function to discover tools
-- \`__tool_namespaces\`: Array of available server namespaces
-- All registered tools as \`server.tool\` functions
-- Standard JavaScript built-ins for data processing
-
-### Example Workflow
-
-\`\`\`javascript
-// 1. Discover available tools
-const github_tools = await search_tools("github pull request");
-console.log(\`Available GitHub PR tools: \${github_tools.map(t => t.name)}\`);
-
-// 2. Call tools with proper parameters
-const pr = await github.get_pull_request({
-    owner: "facebook",
-    repo: "react",
-    number: 12345
-});
-
-// 3. Process results
-let result;
-if (pr.state === 'open' && pr.labels.some(l => l.name === 'bug')) {
-    // 4. Chain with other tools
-    await slack.post_message({
-        channel: "#bugs",
-        text: \`\u{1F41B} Bug PR needs review: \${pr.title}\`
-    });
-    result = "Notification sent";
-} else {
-    result = "No action needed";
+// src/server/utils/runtime.ts
+var isDeno = typeof globalThis.Deno !== "undefined";
+function generateUUID() {
+  return globalThis.crypto.randomUUID();
 }
+__name(generateUUID, "generateUUID");
 
-// 5. Return structured results
-return {
-    pr_number: pr.number,
-    pr_title: pr.title,
-    action_taken: result
-};
-\`\`\`
+// src/telemetry/telemetry.ts
+init_logging();
 
-Remember: Always discover and understand available tools before attempting to use them in code execution.
-`;
+// src/version.ts
+var VERSION = "1.10.0-canary.11";
+function getPackageVersion() {
+  return VERSION;
+}
+__name(getPackageVersion, "getPackageVersion");
 
-// src/client/prompts.ts
-var PROMPTS = {
-  CODE_MODE: CODE_MODE_AGENT_PROMPT
-};
+// src/telemetry/utils.ts
+function getModelProvider(llm) {
+  return llm._llm_type || llm.constructor.name.toLowerCase();
+}
+__name(getModelProvider, "getModelProvider");
+function getModelName(llm) {
+  if ("_identifyingParams" in llm) {
+    const identifyingParams = llm._identifyingParams;
+    if (typeof identifyingParams === "object" && identifyingParams !== null) {
+      for (const key of [
+        "model",
+        "modelName",
+        "model_name",
+        "modelId",
+        "model_id",
+        "deploymentName",
+        "deployment_name"
+      ]) {
+        if (key in identifyingParams) {
+          return String(identifyingParams[key]);
+        }
+      }
+    }
+  }
+  return llm.model || llm.modelName || llm.constructor.name;
+}
+__name(getModelName, "getModelName");
+function extractModelInfo(llm) {
+  return [getModelProvider(llm), getModelName(llm)];
+}
+__name(extractModelInfo, "extractModelInfo");
 
-// src/agents/base.ts
-var BaseAgent = class {
+// src/telemetry/telemetry.ts
+var USER_ID_STORAGE_KEY = "mcp_use_user_id";
+function detectRuntimeEnvironment() {
+  try {
+    if (typeof globalThis.Bun !== "undefined") {
+      return "bun";
+    }
+    if (typeof globalThis.Deno !== "undefined") {
+      return "deno";
+    }
+    if (typeof navigator !== "undefined" && navigator.userAgent?.includes("Cloudflare-Workers")) {
+      return "cloudflare-workers";
+    }
+    if (typeof globalThis.EdgeRuntime !== "undefined") {
+      return "edge";
+    }
+    if (typeof window !== "undefined" && typeof document !== "undefined") {
+      return "browser";
+    }
+    if (typeof process !== "undefined" && typeof process.versions?.node !== "undefined") {
+      return "node";
+    }
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+__name(detectRuntimeEnvironment, "detectRuntimeEnvironment");
+function getStorageCapability(env) {
+  switch (env) {
+    case "node":
+    case "bun":
+      return "filesystem";
+    case "browser":
+      try {
+        if (typeof localStorage !== "undefined") {
+          localStorage.setItem("__mcp_use_test__", "1");
+          localStorage.removeItem("__mcp_use_test__");
+          return "localStorage";
+        }
+      } catch {
+      }
+      return "session-only";
+    case "deno":
+      return "session-only";
+    default:
+      return "session-only";
+  }
+}
+__name(getStorageCapability, "getStorageCapability");
+var cachedEnvironment = null;
+function getRuntimeEnvironment() {
+  if (cachedEnvironment === null) {
+    cachedEnvironment = detectRuntimeEnvironment();
+  }
+  return cachedEnvironment;
+}
+__name(getRuntimeEnvironment, "getRuntimeEnvironment");
+var ScarfEventLogger = class {
   static {
-    __name(this, "BaseAgent");
+    __name(this, "ScarfEventLogger");
   }
-  session;
-  /**
-   * @param session MCP session used for tool invocation
-   */
-  constructor(session) {
-    this.session = session;
+  endpoint;
+  timeout;
+  constructor(endpoint, timeout = 3e3) {
+    this.endpoint = endpoint;
+    this.timeout = timeout;
+  }
+  async logEvent(properties) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(properties),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+    } catch (error) {
+      logger.debug(`Failed to send Scarf event: ${error}`);
+    }
   }
 };
-
-// src/agents/mcp_agent.ts
-var import_langchain2 = require("langchain");
-var import_zod9 = require("zod");
-
-// src/utils/json-schema-to-zod/JSONSchemaToZod.ts
-var import_zod = require("zod");
-var JSONSchemaToZod = class {
+var Telemetry = class _Telemetry {
   static {
-    __name(this, "JSONSchemaToZod");
+    __name(this, "Telemetry");
   }
-  /**
-   * Converts a JSON schema to a Zod schema.
-   *
-   * @param {JSONSchema} schema - The JSON schema.
-   * @returns {ZodSchema} - The Zod schema.
-   */
-  static convert(schema) {
-    return this.parseSchema(schema);
+  static instance = null;
+  PROJECT_API_KEY = "phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI";
+  HOST = "https://eu.i.posthog.com";
+  SCARF_GATEWAY_URL = "https://mcpuse.gateway.scarf.sh/events-ts";
+  UNKNOWN_USER_ID = "UNKNOWN_USER_ID";
+  _currUserId = null;
+  _posthogNodeClient = null;
+  _posthogBrowserClient = null;
+  _posthogLoading = null;
+  _scarfClient = null;
+  _runtimeEnvironment;
+  _storageCapability;
+  _source;
+  // Node.js specific paths (lazily computed)
+  _userIdPath = null;
+  _versionDownloadPath = null;
+  constructor() {
+    this._runtimeEnvironment = getRuntimeEnvironment();
+    this._storageCapability = getStorageCapability(this._runtimeEnvironment);
+    this._source = typeof process !== "undefined" && process.env?.MCP_USE_TELEMETRY_SOURCE || this._runtimeEnvironment;
+    const telemetryDisabled = this._checkTelemetryDisabled();
+    const canSupportTelemetry = this._runtimeEnvironment !== "unknown";
+    if (telemetryDisabled) {
+      this._posthogNodeClient = null;
+      this._posthogBrowserClient = null;
+      this._scarfClient = null;
+      logger.debug("Telemetry disabled via environment/localStorage");
+    } else if (!canSupportTelemetry) {
+      this._posthogNodeClient = null;
+      this._posthogBrowserClient = null;
+      this._scarfClient = null;
+      logger.debug(
+        `Telemetry disabled - unknown environment: ${this._runtimeEnvironment}`
+      );
+    } else {
+      logger.info(
+        "Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable."
+      );
+      this._posthogLoading = this._initPostHog();
+      try {
+        this._scarfClient = new ScarfEventLogger(this.SCARF_GATEWAY_URL, 3e3);
+      } catch (e) {
+        logger.warn(`Failed to initialize Scarf telemetry: ${e}`);
+        this._scarfClient = null;
+      }
+    }
   }
-  /**
-   * Checks if data matches a condition schema.
-   *
-   * @param {JSONValue} data - The data to check.
-   * @param {JSONSchema} condition - The condition schema.
-   * @returns {boolean} - Whether the data matches the condition.
-   */
-  static matchesCondition(data, condition) {
-    if (!condition.properties) {
+  _checkTelemetryDisabled() {
+    if (typeof process !== "undefined" && process.env?.MCP_USE_ANONYMIZED_TELEMETRY?.toLowerCase() === "false") {
       return true;
     }
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      return false;
+    if (typeof localStorage !== "undefined" && localStorage.getItem("MCP_USE_ANONYMIZED_TELEMETRY") === "false") {
+      return true;
     }
-    const objectData = data;
-    for (const [key, propCondition] of Object.entries(condition.properties)) {
-      if (!(key in objectData)) {
-        if ("const" in propCondition) {
-          return false;
-        }
-        continue;
-      }
-      const value = objectData[key];
-      if ("const" in propCondition && value !== propCondition["const"]) {
-        return false;
-      }
-      if ("minimum" in propCondition && typeof value === "number" && value < propCondition["minimum"]) {
-        return false;
-      }
-      if ("maximum" in propCondition && typeof value === "number" && value > propCondition["maximum"]) {
-        return false;
+    return false;
+  }
+  async _initPostHog() {
+    const isBrowser = this._runtimeEnvironment === "browser";
+    if (isBrowser) {
+      await this._initPostHogBrowser();
+    } else {
+      await this._initPostHogNode();
+    }
+  }
+  async _initPostHogBrowser() {
+    try {
+      const posthogModule = await import("posthog-js");
+      const posthog = posthogModule.default || posthogModule.posthog;
+      if (!posthog || typeof posthog.init !== "function") {
+        throw new Error("posthog-js module did not export expected interface");
+      }
+      posthog.init(this.PROJECT_API_KEY, {
+        api_host: this.HOST,
+        persistence: "localStorage",
+        autocapture: false,
+        // We only want explicit captures
+        capture_pageview: false,
+        // We don't want automatic pageview tracking
+        disable_session_recording: true,
+        // No session recording
+        loaded: /* @__PURE__ */ __name(() => {
+          logger.debug("PostHog browser client initialized");
+        }, "loaded")
+      });
+      this._posthogBrowserClient = posthog;
+    } catch (e) {
+      logger.warn(`Failed to initialize PostHog browser telemetry: ${e}`);
+      this._posthogBrowserClient = null;
+    }
+  }
+  async _initPostHogNode() {
+    try {
+      const { PostHog } = await import("posthog-node");
+      const isServerlessEnvironment = [
+        "cloudflare-workers",
+        "edge",
+        "deno"
+      ].includes(this._runtimeEnvironment);
+      const posthogOptions = {
+        host: this.HOST,
+        disableGeoip: false
+      };
+      if (isServerlessEnvironment) {
+        posthogOptions.flushAt = 1;
+        posthogOptions.flushInterval = 0;
       }
+      this._posthogNodeClient = new PostHog(
+        this.PROJECT_API_KEY,
+        posthogOptions
+      );
+      logger.debug("PostHog Node.js client initialized");
+    } catch (e) {
+      logger.warn(`Failed to initialize PostHog Node.js telemetry: ${e}`);
+      this._posthogNodeClient = null;
+    }
+  }
+  /**
+   * Get the detected runtime environment
+   */
+  get runtimeEnvironment() {
+    return this._runtimeEnvironment;
+  }
+  /**
+   * Get the storage capability for this environment
+   */
+  get storageCapability() {
+    return this._storageCapability;
+  }
+  static getInstance() {
+    if (!_Telemetry.instance) {
+      _Telemetry.instance = new _Telemetry();
     }
-    return true;
+    return _Telemetry.instance;
   }
   /**
-   * Validates data against a conditional schema and adds issues to context if validation fails.
-   *
-   * @param {JSONValue} data - The data to validate.
-   * @param {JSONSchema} schema - The conditional schema.
-   * @param {z.RefinementCtx} ctx - The Zod refinement context.
+   * Set the source identifier for telemetry events.
+   * This allows tracking usage from different applications.
+   * @param source - The source identifier (e.g., "my-app", "cli", "vs-code-extension")
    */
-  static validateConditionalSchema(data, schema, ctx) {
-    this.validateRequiredProperties(data, schema, ctx);
-    this.validatePropertyPatterns(data, schema, ctx);
-    this.validateNestedConditions(data, schema, ctx);
+  setSource(source) {
+    this._source = source;
+    logger.debug(`Telemetry source set to: ${source}`);
   }
   /**
-   * Validates that all required properties are present in the data.
-   *
-   * @param {JSONValue} data - The data to validate.
-   * @param {JSONSchema} schema - The schema containing required properties.
-   * @param {z.RefinementCtx} ctx - The Zod refinement context.
+   * Get the current source identifier.
    */
-  static validateRequiredProperties(data, schema, ctx) {
-    if (!schema.required) {
-      return;
-    }
-    if (typeof data !== "object" || data === null) {
-      for (const requiredProp of schema.required) {
-        ctx.addIssue({
-          code: import_zod.z.ZodIssueCode.custom,
-          message: `Required property '${requiredProp}' is missing`,
-          path: [requiredProp]
-        });
-      }
-      return;
-    }
-    for (const requiredProp of schema.required) {
-      if (!(requiredProp in data)) {
-        ctx.addIssue({
-          code: import_zod.z.ZodIssueCode.custom,
-          message: `Required property '${requiredProp}' is missing`,
-          path: [requiredProp]
-        });
-      }
-    }
+  getSource() {
+    return this._source;
   }
   /**
-   * Validates property patterns for string properties.
-   *
-   * @param {JSONValue} data - The data to validate.
-   * @param {JSONSchema} schema - The schema containing property patterns.
-   * @param {z.RefinementCtx} ctx - The Zod refinement context.
+   * Check if telemetry is enabled.
    */
-  static validatePropertyPatterns(data, schema, ctx) {
-    if (!schema.properties) {
-      return;
-    }
-    if (typeof data !== "object" || data === null) {
-      return;
-    }
-    if (Array.isArray(data)) {
-      return;
+  get isEnabled() {
+    return this._posthogNodeClient !== null || this._posthogBrowserClient !== null || this._scarfClient !== null;
+  }
+  get userId() {
+    if (this._currUserId) {
+      return this._currUserId;
     }
-    const objectData = data;
-    for (const [key, propSchema] of Object.entries(schema.properties)) {
-      if (!(key in objectData)) {
-        continue;
+    try {
+      switch (this._storageCapability) {
+        case "filesystem":
+          this._currUserId = this._getUserIdFromFilesystem();
+          break;
+        case "localStorage":
+          this._currUserId = this._getUserIdFromLocalStorage();
+          break;
+        case "session-only":
+        default:
+          this._currUserId = `session-${generateUUID()}`;
+          logger.debug(
+            `Using session-based user ID (${this._runtimeEnvironment} environment)`
+          );
+          break;
       }
-      const value = objectData[key];
-      if (propSchema["pattern"] && typeof value === "string") {
-        const regex = new RegExp(propSchema["pattern"]);
-        if (!regex.test(value)) {
-          ctx.addIssue({
-            code: import_zod.z.ZodIssueCode.custom,
-            message: `String '${value}' does not match pattern '${propSchema["pattern"]}'`,
-            path: [key]
-          });
-        }
+      if (this._storageCapability === "filesystem" && this._currUserId) {
+        this._trackPackageDownloadInternal(this._currUserId, {
+          triggered_by: "user_id_property"
+        }).catch((e) => logger.debug(`Failed to track package download: ${e}`));
       }
+    } catch (e) {
+      logger.debug(`Failed to get/create user ID: ${e}`);
+      this._currUserId = this.UNKNOWN_USER_ID;
     }
+    return this._currUserId;
   }
   /**
-   * Validates nested if-then-else conditions.
-   *
-   * @param {JSONValue} data - The data to validate.
-   * @param {JSONSchema} schema - The schema containing if-then-else conditions.
-   * @param {z.RefinementCtx} ctx - The Zod refinement context.
+   * Get or create user ID from filesystem (Node.js/Bun)
    */
-  static validateNestedConditions(data, schema, ctx) {
-    if (!schema["if"] || !schema["then"]) {
-      return;
+  _getUserIdFromFilesystem() {
+    const fs = require("fs");
+    const os = require("os");
+    const path = require("path");
+    if (!this._userIdPath) {
+      this._userIdPath = path.join(
+        this._getCacheHome(os, path),
+        "mcp_use_3",
+        "telemetry_user_id"
+      );
     }
-    const matchesIf = this.matchesCondition(data, schema["if"]);
-    if (matchesIf) {
-      this.validateConditionalSchema(data, schema["then"], ctx);
-    } else if (schema["else"]) {
-      this.validateConditionalSchema(data, schema["else"], ctx);
+    const isFirstTime = !fs.existsSync(this._userIdPath);
+    if (isFirstTime) {
+      logger.debug(`Creating user ID path: ${this._userIdPath}`);
+      fs.mkdirSync(path.dirname(this._userIdPath), { recursive: true });
+      const newUserId = generateUUID();
+      fs.writeFileSync(this._userIdPath, newUserId);
+      logger.debug(`User ID path created: ${this._userIdPath}`);
+      return newUserId;
     }
+    return fs.readFileSync(this._userIdPath, "utf-8").trim();
   }
   /**
-   * Parses a JSON schema and returns the corresponding Zod schema.
-   * This is the main entry point for schema conversion.
-   *
-   * @param {JSONSchema} schema - The JSON schema.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   * Get or create user ID from localStorage (Browser)
    */
-  static parseSchema(schema) {
-    if (Array.isArray(schema.type)) {
-      return this.handleTypeArray(schema);
-    }
-    if (schema.oneOf || schema.anyOf || schema.allOf) {
-      return this.parseCombinator(schema);
+  _getUserIdFromLocalStorage() {
+    try {
+      let userId = localStorage.getItem(USER_ID_STORAGE_KEY);
+      if (!userId) {
+        userId = generateUUID();
+        localStorage.setItem(USER_ID_STORAGE_KEY, userId);
+        logger.debug(`Created new browser user ID`);
+      }
+      return userId;
+    } catch (e) {
+      logger.debug(`localStorage access failed: ${e}`);
+      return `session-${generateUUID()}`;
     }
-    if (schema["if"] && schema["then"]) {
-      return this.parseObject(schema);
+  }
+  _getCacheHome(os, path) {
+    const envVar = process.env.XDG_CACHE_HOME;
+    if (envVar && path.isAbsolute(envVar)) {
+      return envVar;
     }
-    if (schema.properties && (!schema.type || schema.type === "object")) {
-      return this.parseObject(schema);
+    const platform = process.platform;
+    const homeDir = os.homedir();
+    if (platform === "win32") {
+      const appdata = process.env.LOCALAPPDATA || process.env.APPDATA;
+      if (appdata) {
+        return appdata;
+      }
+      return path.join(homeDir, "AppData", "Local");
+    } else if (platform === "darwin") {
+      return path.join(homeDir, "Library", "Caches");
+    } else {
+      return path.join(homeDir, ".cache");
     }
-    return this.handleSingleType(schema);
   }
-  /**
-   * Handles schemas with an array of types.
-   *
-   * @param {JSONSchema} schema - The JSON schema with type array.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
-   */
-  static handleTypeArray(schema) {
-    if (!Array.isArray(schema.type)) {
-      throw new Error("Expected schema.type to be an array");
+  async capture(event) {
+    if (this._posthogLoading) {
+      await this._posthogLoading;
     }
-    if (schema.type.includes("null")) {
-      return this.handleNullableType(schema);
+    if (!this._posthogNodeClient && !this._posthogBrowserClient && !this._scarfClient) {
+      return;
     }
-    return this.createUnionFromTypes(schema.type, schema);
-  }
-  /**
-   * Handles nullable types by creating a nullable schema.
-   *
-   * @param {JSONSchema} schema - The JSON schema with nullable type.
-   * @returns {ZodTypeAny} - The nullable Zod schema.
-   */
-  static handleNullableType(schema) {
-    if (!Array.isArray(schema.type)) {
-      throw new Error("Expected schema.type to be an array");
+    const properties = { ...event.properties };
+    properties.mcp_use_version = getPackageVersion();
+    properties.language = "typescript";
+    properties.source = this._source;
+    properties.runtime = this._runtimeEnvironment;
+    if (this._posthogNodeClient) {
+      try {
+        logger.debug(`CAPTURE: PostHog Node Event ${event.name}`);
+        this._posthogNodeClient.capture({
+          distinctId: this.userId,
+          event: event.name,
+          properties
+        });
+      } catch (e) {
+        logger.debug(`Failed to track PostHog Node event ${event.name}: ${e}`);
+      }
     }
-    const nonNullSchema = { ...schema };
-    nonNullSchema.type = schema.type.filter((t) => t !== "null");
-    if (nonNullSchema.type.length === 1) {
-      const singleTypeSchema = this.handleSingleType({
-        ...schema,
-        type: nonNullSchema.type[0]
-      });
-      return singleTypeSchema.nullable();
+    if (this._posthogBrowserClient) {
+      try {
+        logger.debug(`CAPTURE: PostHog Browser Event ${event.name}`);
+        this._posthogBrowserClient.capture(event.name, {
+          ...properties,
+          distinct_id: this.userId
+        });
+      } catch (e) {
+        logger.debug(
+          `Failed to track PostHog Browser event ${event.name}: ${e}`
+        );
+      }
+    }
+    if (this._scarfClient) {
+      try {
+        const scarfProperties = {
+          ...properties,
+          user_id: this.userId,
+          event: event.name
+        };
+        await this._scarfClient.logEvent(scarfProperties);
+      } catch (e) {
+        logger.debug(`Failed to track Scarf event ${event.name}: ${e}`);
+      }
     }
-    const unionSchema = this.parseSchema(nonNullSchema);
-    return unionSchema.nullable();
   }
+  // ============================================================================
+  // Package Download Tracking (Node.js only)
+  // ============================================================================
   /**
-   * Creates a union type from an array of types.
-   *
-   * @param {string[]} types - Array of type strings.
-   * @param {JSONSchema} baseSchema - The base schema to apply to each type.
-   * @returns {ZodTypeAny} - The union Zod schema.
+   * Track package download event.
+   * This is a public wrapper that safely accesses userId.
    */
-  static createUnionFromTypes(types, baseSchema) {
-    const schemas = types.map((type) => {
-      const singleTypeSchema = { ...baseSchema, type };
-      return this.parseSchema(singleTypeSchema);
-    });
-    return import_zod.z.union(schemas);
+  async trackPackageDownload(properties) {
+    return this._trackPackageDownloadInternal(this.userId, properties);
   }
   /**
-   * Handles schemas with a single type.
-   *
-   * @param {JSONSchema} schema - The JSON schema with single type.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   * Internal method to track package download with explicit userId.
    */
-  static handleSingleType(schema) {
-    if (schema.type === void 0) {
-      if (schema.oneOf || schema.anyOf || schema.allOf) {
-        return this.parseCombinator(schema);
+  async _trackPackageDownloadInternal(userId, properties) {
+    if (!this._scarfClient) {
+      return;
+    }
+    if (this._storageCapability !== "filesystem") {
+      return;
+    }
+    try {
+      const fs = require("fs");
+      const path = require("path");
+      const os = require("os");
+      if (!this._versionDownloadPath) {
+        this._versionDownloadPath = path.join(
+          this._getCacheHome(os, path),
+          "mcp_use",
+          "download_version"
+        );
       }
-      if (schema.properties) {
-        return this.parseObject(schema);
+      const currentVersion = getPackageVersion();
+      let shouldTrack = false;
+      let firstDownload = false;
+      if (!fs.existsSync(this._versionDownloadPath)) {
+        shouldTrack = true;
+        firstDownload = true;
+        fs.mkdirSync(path.dirname(this._versionDownloadPath), {
+          recursive: true
+        });
+        fs.writeFileSync(this._versionDownloadPath, currentVersion);
+      } else {
+        const savedVersion = fs.readFileSync(this._versionDownloadPath, "utf-8").trim();
+        if (currentVersion > savedVersion) {
+          shouldTrack = true;
+          firstDownload = false;
+          fs.writeFileSync(this._versionDownloadPath, currentVersion);
+        }
       }
-      return import_zod.z.any();
-    }
-    switch (schema.type) {
-      case "string":
-        return this.parseString(schema);
-      case "number":
-      case "integer":
-        return this.parseNumberSchema(schema);
-      case "boolean":
-        return import_zod.z.boolean();
-      case "array":
-        return this.parseArray(schema);
-      case "object":
-        return this.parseObject(schema);
-      default:
-        throw new Error("Unsupported schema type");
+      if (shouldTrack) {
+        logger.debug(
+          `Tracking package download event with properties: ${JSON.stringify(properties)}`
+        );
+        const eventProperties = { ...properties || {} };
+        eventProperties.mcp_use_version = currentVersion;
+        eventProperties.user_id = userId;
+        eventProperties.event = "package_download";
+        eventProperties.first_download = firstDownload;
+        eventProperties.language = "typescript";
+        eventProperties.source = this._source;
+        eventProperties.runtime = this._runtimeEnvironment;
+        await this._scarfClient.logEvent(eventProperties);
+      }
+    } catch (e) {
+      logger.debug(`Failed to track Scarf package_download event: ${e}`);
     }
   }
+  // ============================================================================
+  // Agent Events
+  // ============================================================================
+  async trackAgentExecution(data) {
+    if (!this.isEnabled) return;
+    const event = new MCPAgentExecutionEvent(data);
+    await this.capture(event);
+  }
+  // ============================================================================
+  // Server Events
+  // ============================================================================
   /**
-   * Parses a number schema.
-   *
-   * @param {JSONSchema} schema - The JSON schema for a number.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   * Track server run event directly from an MCPServer instance.
    */
-  static parseNumberSchema(schema) {
-    const numberSchema = import_zod.z.number();
-    let result = numberSchema;
-    result = this.applyNumberBounds(numberSchema, schema);
-    result = this.applyNumberMultipleOf(numberSchema, schema);
-    result = this.applyNumberEnum(numberSchema, schema);
-    result = this.applyIntegerConstraint(numberSchema, schema);
-    return result;
+  async trackServerRunFromServer(server, transport) {
+    if (!this.isEnabled) return;
+    const data = createServerRunEventData(server, transport);
+    const event = new ServerRunEvent(data);
+    await this.capture(event);
   }
-  /**
-   * Applies bounds validation to a number schema.
-   *
-   * @param {z.ZodNumber} numberSchema - The base number schema.
-   * @param {JSONSchema} schema - The JSON schema with bounds.
-   * @returns {z.ZodNumber} - The updated schema with bounds validation.
-   */
-  static applyNumberBounds(numberSchema, schema) {
-    let result = numberSchema;
-    if (schema["minimum"] !== void 0) {
-      result = schema["exclusiveMinimum"] ? result.gt(schema["minimum"]) : result.gte(schema["minimum"]);
-    }
-    if (schema["maximum"] !== void 0) {
-      result = schema["exclusiveMaximum"] ? result.lt(schema["maximum"]) : result.lte(schema["maximum"]);
-    }
-    return result;
+  async trackServerInitialize(data) {
+    if (!this.isEnabled) return;
+    const event = new ServerInitializeEvent(data);
+    await this.capture(event);
   }
-  /**
-   * Applies multipleOf validation to a number schema.
-   *
-   * @param {z.ZodNumber} numberSchema - The base number schema.
-   * @param {JSONSchema} schema - The JSON schema with multipleOf.
-   * @returns {z.ZodNumber} - The updated schema with multipleOf validation.
-   */
-  static applyNumberMultipleOf(numberSchema, schema) {
-    if (schema["multipleOf"] === void 0) {
-      return numberSchema;
-    }
-    return numberSchema.refine((val) => val % schema["multipleOf"] === 0, {
-      message: `Number must be a multiple of ${schema["multipleOf"]}`
+  async trackServerToolCall(data) {
+    if (!this.isEnabled) return;
+    const event = new ServerToolCallEvent(data);
+    await this.capture(event);
+  }
+  async trackServerResourceCall(data) {
+    if (!this.isEnabled) return;
+    const event = new ServerResourceCallEvent(data);
+    await this.capture(event);
+  }
+  async trackServerPromptCall(data) {
+    if (!this.isEnabled) return;
+    const event = new ServerPromptCallEvent(data);
+    await this.capture(event);
+  }
+  async trackServerContext(data) {
+    if (!this.isEnabled) return;
+    const event = new ServerContextEvent(data);
+    await this.capture(event);
+  }
+  // ============================================================================
+  // Client Events
+  // ============================================================================
+  async trackMCPClientInit(data) {
+    if (!this.isEnabled) return;
+    const event = new MCPClientInitEvent(data);
+    await this.capture(event);
+  }
+  async trackConnectorInit(data) {
+    if (!this.isEnabled) return;
+    const event = new ConnectorInitEvent(data);
+    await this.capture(event);
+  }
+  async trackClientAddServer(serverName, serverConfig) {
+    if (!this.isEnabled) return;
+    const event = new ClientAddServerEvent({ serverName, serverConfig });
+    await this.capture(event);
+  }
+  async trackClientRemoveServer(serverName) {
+    if (!this.isEnabled) return;
+    const event = new ClientRemoveServerEvent({ serverName });
+    await this.capture(event);
+  }
+  // ============================================================================
+  // React Hook / Browser specific events
+  // ============================================================================
+  async trackUseMcpConnection(data) {
+    if (!this.isEnabled) return;
+    await this.capture({
+      name: "usemcp_connection",
+      properties: {
+        url_domain: new URL(data.url).hostname,
+        // Only domain for privacy
+        transport_type: data.transportType,
+        success: data.success,
+        error_type: data.errorType ?? null,
+        connection_time_ms: data.connectionTimeMs ?? null,
+        has_oauth: data.hasOAuth,
+        has_sampling: data.hasSampling,
+        has_elicitation: data.hasElicitation
+      }
     });
   }
-  /**
-   * Applies enum validation to a number schema.
-   *
-   * @param {z.ZodNumber} numberSchema - The base number schema.
-   * @param {JSONSchema} schema - The JSON schema with enum.
-   * @returns {z.ZodNumber} - The updated schema with enum validation.
-   */
-  static applyNumberEnum(numberSchema, schema) {
-    if (!schema.enum) {
-      return numberSchema;
-    }
-    const numberEnums = schema.enum.filter(
-      (val) => typeof val === "number"
-    );
-    if (numberEnums.length === 0) {
-      return numberSchema;
-    }
-    return numberSchema.refine((val) => numberEnums.includes(val), {
-      message: `Number must be one of: ${numberEnums.join(", ")}`
+  async trackUseMcpToolCall(data) {
+    if (!this.isEnabled) return;
+    await this.capture({
+      name: "usemcp_tool_call",
+      properties: {
+        tool_name: data.toolName,
+        success: data.success,
+        error_type: data.errorType ?? null,
+        execution_time_ms: data.executionTimeMs ?? null
+      }
     });
   }
+  async trackUseMcpResourceRead(data) {
+    if (!this.isEnabled) return;
+    await this.capture({
+      name: "usemcp_resource_read",
+      properties: {
+        resource_uri_scheme: data.resourceUri.split(":")[0],
+        // Only scheme for privacy
+        success: data.success,
+        error_type: data.errorType ?? null
+      }
+    });
+  }
+  // ============================================================================
+  // Browser-specific Methods
+  // ============================================================================
   /**
-   * Applies integer constraint to a number schema if needed.
-   *
-   * @param {z.ZodNumber} numberSchema - The base number schema.
-   * @param {JSONSchema} schema - The JSON schema.
-   * @returns {z.ZodNumber} - The updated schema with integer validation if needed.
+   * Identify the current user (useful for linking sessions)
+   * Browser only - no-op in Node.js
    */
-  static applyIntegerConstraint(numberSchema, schema) {
-    if (schema.type !== "integer") {
-      return numberSchema;
+  identify(userId, properties) {
+    if (this._posthogBrowserClient) {
+      try {
+        this._posthogBrowserClient.identify(userId, properties);
+      } catch (e) {
+        logger.debug(`Failed to identify user: ${e}`);
+      }
     }
-    return numberSchema.refine((val) => Number.isInteger(val), {
-      message: "Number must be an integer"
-    });
   }
   /**
-   * Parses a string schema.
-   *
-   * @param {JSONSchema} schema - The JSON schema for a string.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   * Reset the user identity (useful for logout)
+   * Browser only - no-op in Node.js
    */
-  static parseString(schema) {
-    const stringSchema = import_zod.z.string();
-    let result = stringSchema;
-    if (schema.format) {
-      return this.applyStringFormat(stringSchema, schema);
-    } else {
-      result = this.applyStringPattern(stringSchema, schema);
-      result = this.applyStringLength(stringSchema, schema);
-      result = this.applyStringEnum(stringSchema, schema);
+  reset() {
+    if (this._posthogBrowserClient) {
+      try {
+        this._posthogBrowserClient.reset();
+      } catch (e) {
+        logger.debug(`Failed to reset user: ${e}`);
+      }
     }
-    return result;
+    this._currUserId = null;
   }
+  // ============================================================================
+  // Node.js-specific Methods
+  // ============================================================================
   /**
-   * Applies format validation to a string schema.
-   *
-   * @param {z.ZodString} stringSchema - The base string schema.
-   * @param {JSONSchema} schema - The JSON schema with format.
-   * @returns {ZodTypeAny} - The updated schema with format validation.
+   * Flush the telemetry queue (Node.js only)
    */
-  static applyStringFormat(stringSchema, schema) {
-    if (!schema.format) {
-      return stringSchema;
-    }
-    switch (schema.format) {
-      case "email":
-        return stringSchema.email();
-      case "date-time":
-        return stringSchema.datetime();
-      case "uri":
-        return stringSchema.url();
-      case "uuid":
-        return stringSchema.uuid();
-      case "date":
-        return stringSchema.date();
-      default:
-        return stringSchema;
+  flush() {
+    if (this._posthogNodeClient) {
+      try {
+        this._posthogNodeClient.flush();
+        logger.debug("PostHog client telemetry queue flushed");
+      } catch (e) {
+        logger.debug(`Failed to flush PostHog client: ${e}`);
+      }
     }
   }
   /**
-   * Applies pattern validation to a string schema.
-   *
-   * @param {z.ZodString} stringSchema - The base string schema.
-   * @param {JSONSchema} schema - The JSON schema with pattern.
-   * @returns {z.ZodString} - The updated schema with pattern validation.
+   * Shutdown the telemetry client (Node.js only)
    */
-  static applyStringPattern(stringSchema, schema) {
-    if (!schema["pattern"]) {
-      return stringSchema;
+  shutdown() {
+    if (this._posthogNodeClient) {
+      try {
+        this._posthogNodeClient.shutdown();
+        logger.debug("PostHog client shutdown successfully");
+      } catch (e) {
+        logger.debug(`Error shutting down PostHog client: ${e}`);
+      }
     }
-    const regex = new RegExp(schema["pattern"]);
-    return stringSchema.regex(regex, {
-      message: `String must match pattern: ${schema["pattern"]}`
+  }
+};
+
+// src/client/connectors/codeMode.ts
+var CODE_MODE_AGENT_PROMPT = `
+## MCP Code Mode Tool Usage Guide
+
+You have access to an MCP Code Mode Client that allows you to execute JavaScript/TypeScript code with access to registered tools. Follow this workflow:
+
+### 1. Tool Discovery Phase
+**Always start by discovering available tools:**
+- Tools are organized by server namespace (e.g., \`server_name.tool_name\`)
+- Use the \`search_tools(query, detail_level)\` function to find available tools
+- You can access \`__tool_namespaces\` to see all available server namespaces
+
+\`\`\`javascript
+// Find all GitHub-related tools
+const tools = await search_tools("github");
+for (const tool of tools) {
+    console.log(\`\${tool.server}.\${tool.name}: \${tool.description}\`);
+}
+
+// Get only tool names for quick overview
+const tools = await search_tools("", "names");
+\`\`\`
+
+### 2. Interface Introspection
+**Understand tool contracts before using them:**
+- Use \`search_tools\` to get tool descriptions and input schemas
+- Look for "Access as: server.tool(args)" patterns in descriptions
+
+### 3. Code Execution Guidelines
+**When writing code:**
+- Use \`await server.tool({ param: value })\` syntax for all tool calls
+- Tools are async functions that return promises
+- You have access to standard JavaScript globals: \`console\`, \`JSON\`, \`Math\`, \`Date\`, etc.
+- All console output (\`console.log\`, \`console.error\`, etc.) is automatically captured and returned
+- Build properly structured input objects based on interface definitions
+- Handle errors appropriately with try/catch blocks
+- Chain tool calls by using results from previous calls
+
+### 4. Best Practices
+- **Discover first, code second**: Always explore available tools before writing execution code
+- **Respect namespaces**: Use full \`server.tool\` names to avoid conflicts
+- **Minimize Context**: Process large data in code, return only essential results
+- **Error handling**: Wrap tool calls in try/catch for robustness
+- **Data flow**: Chain tools by passing outputs as inputs to subsequent tools
+
+### 5. Available Runtime Context
+- \`search_tools(query, detail_level)\`: Function to discover tools
+- \`__tool_namespaces\`: Array of available server namespaces
+- All registered tools as \`server.tool\` functions
+- Standard JavaScript built-ins for data processing
+
+### Example Workflow
+
+\`\`\`javascript
+// 1. Discover available tools
+const github_tools = await search_tools("github pull request");
+console.log(\`Available GitHub PR tools: \${github_tools.map(t => t.name)}\`);
+
+// 2. Call tools with proper parameters
+const pr = await github.get_pull_request({
+    owner: "facebook",
+    repo: "react",
+    number: 12345
+});
+
+// 3. Process results
+let result;
+if (pr.state === 'open' && pr.labels.some(l => l.name === 'bug')) {
+    // 4. Chain with other tools
+    await slack.post_message({
+        channel: "#bugs",
+        text: \`\u{1F41B} Bug PR needs review: \${pr.title}\`
     });
+    result = "Notification sent";
+} else {
+    result = "No action needed";
+}
+
+// 5. Return structured results
+return {
+    pr_number: pr.number,
+    pr_title: pr.title,
+    action_taken: result
+};
+\`\`\`
+
+Remember: Always discover and understand available tools before attempting to use them in code execution.
+`;
+
+// src/client/prompts.ts
+var PROMPTS = {
+  CODE_MODE: CODE_MODE_AGENT_PROMPT
+};
+
+// src/agents/base.ts
+var BaseAgent = class {
+  static {
+    __name(this, "BaseAgent");
   }
+  session;
   /**
-   * Applies length constraints to a string schema.
-   *
-   * @param {z.ZodString} stringSchema - The base string schema.
-   * @param {JSONSchema} schema - The JSON schema with length constraints.
-   * @returns {z.ZodString} - The updated schema with length validation.
+   * @param session MCP session used for tool invocation
    */
-  static applyStringLength(stringSchema, schema) {
-    const result = stringSchema;
-    if (schema["minLength"] !== void 0) {
-      stringSchema = stringSchema.min(schema["minLength"]);
-    }
-    if (schema["maxLength"] !== void 0) {
-      stringSchema = stringSchema.max(schema["maxLength"]);
-    }
-    return result;
+  constructor(session) {
+    this.session = session;
   }
-  /**
-   * Applies enum validation to a string schema.
-   *
-   * @param {z.ZodString} stringSchema - The base string schema.
-   * @param {JSONSchema} schema - The JSON schema with enum.
-   * @returns {ZodTypeAny} - The updated schema with enum validation.
-   */
-  static applyStringEnum(stringSchema, schema) {
-    if (!schema.enum) {
-      return stringSchema;
-    }
-    return stringSchema.refine((val) => schema.enum?.includes(val), {
-      message: `Value must be one of: ${schema.enum?.join(", ")}`
-    });
+};
+
+// src/agents/mcp_agent.ts
+var import_langchain2 = require("langchain");
+var import_zod9 = require("zod");
+
+// src/utils/json-schema-to-zod/JSONSchemaToZod.ts
+var import_zod = require("zod");
+var JSONSchemaToZod = class {
+  static {
+    __name(this, "JSONSchemaToZod");
   }
   /**
-   * Parses a JSON schema of type array and returns the corresponding Zod schema.
+   * Converts a JSON schema to a Zod schema.
    *
    * @param {JSONSchema} schema - The JSON schema.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   * @returns {ZodSchema} - The Zod schema.
    */
-  static parseArray(schema) {
-    if (Array.isArray(schema.items)) {
-      const tupleSchemas = schema.items.map((item) => this.parseSchema(item));
-      return import_zod.z.union(tupleSchemas);
-    }
-    const itemSchema = schema.items ? this.parseSchema(schema.items) : import_zod.z.any();
-    const arraySchema = import_zod.z.array(itemSchema);
-    let result = arraySchema;
-    result = this.applyArrayConstraints(arraySchema, schema);
-    return result;
+  static convert(schema) {
+    return this.parseSchema(schema);
   }
   /**
-   * Applies constraints to an array schema.
+   * Checks if data matches a condition schema.
    *
-   * @param {z.ZodArray<any>} arraySchema - The base array schema.
-   * @param {JSONSchema} schema - The JSON schema with array constraints.
-   * @returns {z.ZodTypeAny} - The updated array schema with constraints.
+   * @param {JSONValue} data - The data to check.
+   * @param {JSONSchema} condition - The condition schema.
+   * @returns {boolean} - Whether the data matches the condition.
    */
-  static applyArrayConstraints(arraySchema, schema) {
-    if (schema["minItems"] !== void 0) {
-      arraySchema = arraySchema.min(schema["minItems"]);
+  static matchesCondition(data, condition) {
+    if (!condition.properties) {
+      return true;
     }
-    if (schema["maxItems"] !== void 0) {
-      arraySchema = arraySchema.max(schema["maxItems"]);
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+      return false;
     }
-    if (schema["uniqueItems"]) {
-      return arraySchema.refine(
-        (items) => new Set(items).size === items.length,
-        { message: "Array items must be unique" }
-      );
+    const objectData = data;
+    for (const [key, propCondition] of Object.entries(condition.properties)) {
+      if (!(key in objectData)) {
+        if ("const" in propCondition) {
+          return false;
+        }
+        continue;
+      }
+      const value = objectData[key];
+      if ("const" in propCondition && value !== propCondition["const"]) {
+        return false;
+      }
+      if ("minimum" in propCondition && typeof value === "number" && value < propCondition["minimum"]) {
+        return false;
+      }
+      if ("maximum" in propCondition && typeof value === "number" && value > propCondition["maximum"]) {
+        return false;
+      }
     }
-    return arraySchema;
+    return true;
   }
   /**
-   * Parses an object schema.
+   * Validates data against a conditional schema and adds issues to context if validation fails.
    *
-   * @param {JSONSchema} schema - The JSON schema for an object.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   * @param {JSONValue} data - The data to validate.
+   * @param {JSONSchema} schema - The conditional schema.
+   * @param {z.RefinementCtx} ctx - The Zod refinement context.
    */
-  static parseObject(schema) {
-    if (schema["if"] && schema["then"]) {
-      return this.parseConditional(schema);
-    }
-    const shape = {};
-    this.processObjectProperties(schema, shape);
-    return this.processAdditionalProperties(schema, import_zod.z.object(shape));
+  static validateConditionalSchema(data, schema, ctx) {
+    this.validateRequiredProperties(data, schema, ctx);
+    this.validatePropertyPatterns(data, schema, ctx);
+    this.validateNestedConditions(data, schema, ctx);
   }
   /**
-   * Processes object properties and builds the shape object.
+   * Validates that all required properties are present in the data.
    *
-   * @param {JSONSchema} schema - The JSON schema for an object.
-   * @param {Record<string, ZodTypeAny>} shape - The shape object to populate.
+   * @param {JSONValue} data - The data to validate.
+   * @param {JSONSchema} schema - The schema containing required properties.
+   * @param {z.RefinementCtx} ctx - The Zod refinement context.
    */
-  static processObjectProperties(schema, shape) {
-    const required = new Set(schema.required || []);
-    if (!schema.properties) {
+  static validateRequiredProperties(data, schema, ctx) {
+    if (!schema.required) {
       return;
     }
-    for (const [key, propSchema] of Object.entries(schema.properties)) {
-      const zodSchema = this.parseSchema(propSchema);
-      shape[key] = required.has(key) ? zodSchema : zodSchema.optional();
-    }
-  }
-  /**
-   * Processes additionalProperties configuration.
-   *
-   * @param {JSONSchema} schema - The JSON schema for an object.
-   * @param {z.ZodObject<any, any>} objectSchema - The Zod object schema.
-   * @returns {z.ZodObject<any, any>} - The updated Zod object schema.
-   */
-  static processAdditionalProperties(schema, objectSchema) {
-    if (schema.additionalProperties === true) {
-      return objectSchema.passthrough();
-    } else if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
-      const additionalPropSchema = this.parseSchema(
-        schema.additionalProperties
-      );
-      return objectSchema.catchall(additionalPropSchema);
-    } else {
-      return objectSchema.strict();
+    if (typeof data !== "object" || data === null) {
+      for (const requiredProp of schema.required) {
+        ctx.addIssue({
+          code: import_zod.z.ZodIssueCode.custom,
+          message: `Required property '${requiredProp}' is missing`,
+          path: [requiredProp]
+        });
+      }
+      return;
     }
-  }
-  /**
-   * Parses a conditional schema with if-then-else.
-   *
-   * @param {JSONSchema} schema - The JSON schema with conditional validation.
-   * @returns {ZodTypeAny} - The conditional Zod schema.
-   */
-  static parseConditional(schema) {
-    const zodObject = this.createBaseObjectSchema(schema);
-    const ifCondition = schema["if"];
-    const thenSchema = schema["then"];
-    const elseSchema = schema["else"];
-    return zodObject.superRefine((data, ctx) => {
-      const dataWithDefaults = this.applyDefaultValues(
-        data,
-        schema
-      );
-      if (this.matchesCondition(dataWithDefaults, ifCondition)) {
-        this.validateConditionalSchema(dataWithDefaults, thenSchema, ctx);
-      } else if (elseSchema) {
-        this.validateConditionalSchema(dataWithDefaults, elseSchema, ctx);
+    for (const requiredProp of schema.required) {
+      if (!(requiredProp in data)) {
+        ctx.addIssue({
+          code: import_zod.z.ZodIssueCode.custom,
+          message: `Required property '${requiredProp}' is missing`,
+          path: [requiredProp]
+        });
       }
-    });
-  }
-  /**
-   * Creates a base object schema from the given JSON schema.
-   *
-   * @param {JSONSchema} schema - The JSON schema.
-   * @returns {z.ZodObject<any, any>} - The base Zod object schema.
-   */
-  static createBaseObjectSchema(schema) {
-    const shape = {};
-    const required = new Set(schema.required || []);
-    for (const [key, value] of Object.entries(schema.properties || {})) {
-      const zodSchema = this.parseSchema(value);
-      shape[key] = required.has(key) ? zodSchema : zodSchema.optional();
     }
-    const zodObject = import_zod.z.object(shape);
-    return this.processAdditionalProperties(schema, zodObject);
   }
   /**
-   * Applies default values from schema properties to data object.
+   * Validates property patterns for string properties.
    *
-   * @param {JSONValue} data - The original data object.
-   * @param {JSONSchema} schema - The schema with default values.
-   * @returns {JSONValue} - The data object with defaults applied.
+   * @param {JSONValue} data - The data to validate.
+   * @param {JSONSchema} schema - The schema containing property patterns.
+   * @param {z.RefinementCtx} ctx - The Zod refinement context.
    */
-  static applyDefaultValues(data, schema) {
+  static validatePropertyPatterns(data, schema, ctx) {
+    if (!schema.properties) {
+      return;
+    }
     if (typeof data !== "object" || data === null) {
-      return data;
+      return;
     }
     if (Array.isArray(data)) {
-      return data;
+      return;
     }
     const objectData = data;
-    const dataWithDefaults = { ...objectData };
-    if (!schema.properties) {
-      return dataWithDefaults;
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      if (!(key in objectData)) {
+        continue;
+      }
+      const value = objectData[key];
+      if (propSchema["pattern"] && typeof value === "string") {
+        const regex = new RegExp(propSchema["pattern"]);
+        if (!regex.test(value)) {
+          ctx.addIssue({
+            code: import_zod.z.ZodIssueCode.custom,
+            message: `String '${value}' does not match pattern '${propSchema["pattern"]}'`,
+            path: [key]
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Validates nested if-then-else conditions.
+   *
+   * @param {JSONValue} data - The data to validate.
+   * @param {JSONSchema} schema - The schema containing if-then-else conditions.
+   * @param {z.RefinementCtx} ctx - The Zod refinement context.
+   */
+  static validateNestedConditions(data, schema, ctx) {
+    if (!schema["if"] || !schema["then"]) {
+      return;
     }
-    for (const [key, propSchema] of Object.entries(schema.properties)) {
-      if (!(key in dataWithDefaults) && "default" in propSchema) {
-        dataWithDefaults[key] = propSchema["default"];
-      }
+    const matchesIf = this.matchesCondition(data, schema["if"]);
+    if (matchesIf) {
+      this.validateConditionalSchema(data, schema["then"], ctx);
+    } else if (schema["else"]) {
+      this.validateConditionalSchema(data, schema["else"], ctx);
     }
-    return dataWithDefaults;
   }
   /**
-   * Parses a schema with combinators (oneOf, anyOf, allOf).
-   * Delegates to the appropriate combinator parser based on which combinator is present.
+   * Parses a JSON schema and returns the corresponding Zod schema.
+   * This is the main entry point for schema conversion.
    *
-   * @param {JSONSchema} schema - The JSON schema with combinators.
+   * @param {JSONSchema} schema - The JSON schema.
    * @returns {ZodTypeAny} - The ZodTypeAny schema.
    */
-  static parseCombinator(schema) {
-    if (schema.oneOf) {
-      return this.parseOneOf(schema.oneOf);
+  static parseSchema(schema) {
+    if (Array.isArray(schema.type)) {
+      return this.handleTypeArray(schema);
     }
-    if (schema.anyOf) {
-      return this.parseAnyOf(schema.anyOf);
+    if (schema.oneOf || schema.anyOf || schema.allOf) {
+      return this.parseCombinator(schema);
     }
-    if (schema.allOf) {
-      return this.parseAllOf(schema.allOf);
+    if (schema["if"] && schema["then"]) {
+      return this.parseObject(schema);
     }
-    throw new Error("Unsupported schema type");
+    if (schema.properties && (!schema.type || schema.type === "object")) {
+      return this.parseObject(schema);
+    }
+    return this.handleSingleType(schema);
   }
   /**
-   * Parses a oneOf combinator schema.
+   * Handles schemas with an array of types.
    *
-   * @param {JSONSchema[]} schemas - Array of JSON schemas in the oneOf.
+   * @param {JSONSchema} schema - The JSON schema with type array.
    * @returns {ZodTypeAny} - The ZodTypeAny schema.
    */
-  static parseOneOf(schemas) {
-    return this.createUnionFromSchemas(schemas);
+  static handleTypeArray(schema) {
+    if (!Array.isArray(schema.type)) {
+      throw new Error("Expected schema.type to be an array");
+    }
+    if (schema.type.includes("null")) {
+      return this.handleNullableType(schema);
+    }
+    return this.createUnionFromTypes(schema.type, schema);
   }
   /**
-   * Parses an anyOf combinator schema.
+   * Handles nullable types by creating a nullable schema.
    *
-   * @param {JSONSchema[]} schemas - Array of JSON schemas in the anyOf.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   * @param {JSONSchema} schema - The JSON schema with nullable type.
+   * @returns {ZodTypeAny} - The nullable Zod schema.
    */
-  static parseAnyOf(schemas) {
-    return this.createUnionFromSchemas(schemas);
+  static handleNullableType(schema) {
+    if (!Array.isArray(schema.type)) {
+      throw new Error("Expected schema.type to be an array");
+    }
+    const nonNullSchema = { ...schema };
+    nonNullSchema.type = schema.type.filter((t) => t !== "null");
+    if (nonNullSchema.type.length === 1) {
+      const singleTypeSchema = this.handleSingleType({
+        ...schema,
+        type: nonNullSchema.type[0]
+      });
+      return singleTypeSchema.nullable();
+    }
+    const unionSchema = this.parseSchema(nonNullSchema);
+    return unionSchema.nullable();
   }
   /**
-   * Creates a union from an array of schemas, handling special cases.
+   * Creates a union type from an array of types.
    *
-   * @param {JSONSchema[]} schemas - Array of JSON schemas to create a union from.
+   * @param {string[]} types - Array of type strings.
+   * @param {JSONSchema} baseSchema - The base schema to apply to each type.
    * @returns {ZodTypeAny} - The union Zod schema.
    */
-  static createUnionFromSchemas(schemas) {
-    if (schemas.length === 0) {
+  static createUnionFromTypes(types, baseSchema) {
+    const schemas = types.map((type) => {
+      const singleTypeSchema = { ...baseSchema, type };
+      return this.parseSchema(singleTypeSchema);
+    });
+    return import_zod.z.union(schemas);
+  }
+  /**
+   * Handles schemas with a single type.
+   *
+   * @param {JSONSchema} schema - The JSON schema with single type.
+   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   */
+  static handleSingleType(schema) {
+    if (schema.type === void 0) {
+      if (schema.oneOf || schema.anyOf || schema.allOf) {
+        return this.parseCombinator(schema);
+      }
+      if (schema.properties) {
+        return this.parseObject(schema);
+      }
       return import_zod.z.any();
     }
-    if (schemas.length === 1) {
-      return this.parseSchema(schemas[0]);
+    switch (schema.type) {
+      case "string":
+        return this.parseString(schema);
+      case "number":
+      case "integer":
+        return this.parseNumberSchema(schema);
+      case "boolean":
+        return import_zod.z.boolean();
+      case "array":
+        return this.parseArray(schema);
+      case "object":
+        return this.parseObject(schema);
+      default:
+        throw new Error("Unsupported schema type");
     }
-    const zodSchemas = [];
-    for (const subSchema of schemas) {
-      if (subSchema.type === "null") {
-        zodSchemas.push(import_zod.z.null());
-      } else {
-        zodSchemas.push(this.parseSchema(subSchema));
-      }
+  }
+  /**
+   * Parses a number schema.
+   *
+   * @param {JSONSchema} schema - The JSON schema for a number.
+   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   */
+  static parseNumberSchema(schema) {
+    const numberSchema = import_zod.z.number();
+    let result = numberSchema;
+    result = this.applyNumberBounds(numberSchema, schema);
+    result = this.applyNumberMultipleOf(numberSchema, schema);
+    result = this.applyNumberEnum(numberSchema, schema);
+    result = this.applyIntegerConstraint(numberSchema, schema);
+    return result;
+  }
+  /**
+   * Applies bounds validation to a number schema.
+   *
+   * @param {z.ZodNumber} numberSchema - The base number schema.
+   * @param {JSONSchema} schema - The JSON schema with bounds.
+   * @returns {z.ZodNumber} - The updated schema with bounds validation.
+   */
+  static applyNumberBounds(numberSchema, schema) {
+    let result = numberSchema;
+    if (schema["minimum"] !== void 0) {
+      result = schema["exclusiveMinimum"] ? result.gt(schema["minimum"]) : result.gte(schema["minimum"]);
     }
-    if (zodSchemas.length >= 2) {
-      return import_zod.z.union(zodSchemas);
-    } else if (zodSchemas.length === 1) {
-      return zodSchemas[0];
+    if (schema["maximum"] !== void 0) {
+      result = schema["exclusiveMaximum"] ? result.lt(schema["maximum"]) : result.lte(schema["maximum"]);
     }
-    return import_zod.z.any();
+    return result;
   }
   /**
-   * Parses an allOf combinator schema by merging all schemas.
+   * Applies multipleOf validation to a number schema.
    *
-   * @param {JSONSchema[]} schemas - Array of JSON schemas in the allOf.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   * @param {z.ZodNumber} numberSchema - The base number schema.
+   * @param {JSONSchema} schema - The JSON schema with multipleOf.
+   * @returns {z.ZodNumber} - The updated schema with multipleOf validation.
    */
-  static parseAllOf(schemas) {
-    if (schemas.length === 0) {
-      return import_zod.z.any();
+  static applyNumberMultipleOf(numberSchema, schema) {
+    if (schema["multipleOf"] === void 0) {
+      return numberSchema;
     }
-    if (schemas.length === 1) {
-      return this.parseSchema(schemas[0]);
+    return numberSchema.refine((val) => val % schema["multipleOf"] === 0, {
+      message: `Number must be a multiple of ${schema["multipleOf"]}`
+    });
+  }
+  /**
+   * Applies enum validation to a number schema.
+   *
+   * @param {z.ZodNumber} numberSchema - The base number schema.
+   * @param {JSONSchema} schema - The JSON schema with enum.
+   * @returns {z.ZodNumber} - The updated schema with enum validation.
+   */
+  static applyNumberEnum(numberSchema, schema) {
+    if (!schema.enum) {
+      return numberSchema;
     }
-    const mergedSchema = schemas.reduce(
-      (acc, currentSchema) => this.mergeSchemas(acc, currentSchema)
+    const numberEnums = schema.enum.filter(
+      (val) => typeof val === "number"
     );
-    return this.parseSchema(mergedSchema);
+    if (numberEnums.length === 0) {
+      return numberSchema;
+    }
+    return numberSchema.refine((val) => numberEnums.includes(val), {
+      message: `Number must be one of: ${numberEnums.join(", ")}`
+    });
   }
   /**
-   * Merges two JSON schemas together.
+   * Applies integer constraint to a number schema if needed.
    *
-   * @param {JSONSchema} baseSchema - The base JSON schema.
-   * @param {JSONSchema} addSchema - The JSON schema to add.
-   * @returns {JSONSchema} - The merged JSON schema
+   * @param {z.ZodNumber} numberSchema - The base number schema.
+   * @param {JSONSchema} schema - The JSON schema.
+   * @returns {z.ZodNumber} - The updated schema with integer validation if needed.
    */
-  static mergeSchemas(baseSchema, addSchema) {
-    const merged = { ...baseSchema, ...addSchema };
-    if (baseSchema.properties && addSchema.properties) {
-      const mergedProperties = {
-        ...baseSchema.properties,
-        ...addSchema.properties
-      };
-      merged.properties = mergedProperties;
-    }
-    if (baseSchema.required && addSchema.required) {
-      const mergedRequired = [
-        .../* @__PURE__ */ new Set([...baseSchema.required, ...addSchema.required])
-      ];
-      merged.required = mergedRequired;
+  static applyIntegerConstraint(numberSchema, schema) {
+    if (schema.type !== "integer") {
+      return numberSchema;
     }
-    return merged;
+    return numberSchema.refine((val) => Number.isInteger(val), {
+      message: "Number must be an integer"
+    });
   }
-};
-
-// src/adapters/langchain_adapter.ts
-var import_tools = require("@langchain/core/tools");
-var import_zod2 = require("zod");
-init_logging();
-
-// src/adapters/base.ts
-init_logging();
-var BaseAdapter = class {
-  static {
-    __name(this, "BaseAdapter");
+  /**
+   * Parses a string schema.
+   *
+   * @param {JSONSchema} schema - The JSON schema for a string.
+   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   */
+  static parseString(schema) {
+    const stringSchema = import_zod.z.string();
+    let result = stringSchema;
+    if (schema.format) {
+      return this.applyStringFormat(stringSchema, schema);
+    } else {
+      result = this.applyStringPattern(stringSchema, schema);
+      result = this.applyStringLength(stringSchema, schema);
+      result = this.applyStringEnum(stringSchema, schema);
+    }
+    return result;
   }
   /**
-   * List of tool names that should not be available.
-   */
-  disallowedTools;
-  /**
-   * Internal cache that maps a connector instance to the list of tools
-   * generated for it.
+   * Applies format validation to a string schema.
+   *
+   * @param {z.ZodString} stringSchema - The base string schema.
+   * @param {JSONSchema} schema - The JSON schema with format.
+   * @returns {ZodTypeAny} - The updated schema with format validation.
    */
-  connectorToolMap = /* @__PURE__ */ new Map();
-  constructor(disallowedTools) {
-    this.disallowedTools = disallowedTools ?? [];
+  static applyStringFormat(stringSchema, schema) {
+    if (!schema.format) {
+      return stringSchema;
+    }
+    switch (schema.format) {
+      case "email":
+        return stringSchema.email();
+      case "date-time":
+        return stringSchema.datetime();
+      case "uri":
+        return stringSchema.url();
+      case "uuid":
+        return stringSchema.uuid();
+      case "date":
+        return stringSchema.date();
+      default:
+        return stringSchema;
+    }
   }
   /**
-   * Create tools from an MCPClient instance.
-   *
-   * This is the recommended way to create tools from an MCPClient, as it handles
-   * session creation and connector extraction automatically.
+   * Applies pattern validation to a string schema.
    *
-   * @param client          The MCPClient to extract tools from.
-   * @param disallowedTools Optional list of tool names to exclude.
-   * @returns               A promise that resolves with a list of converted tools.
+   * @param {z.ZodString} stringSchema - The base string schema.
+   * @param {JSONSchema} schema - The JSON schema with pattern.
+   * @returns {z.ZodString} - The updated schema with pattern validation.
    */
-  static async createTools(client, disallowedTools) {
-    const adapter = new this(disallowedTools);
-    if (!client.activeSessions || Object.keys(client.activeSessions).length === 0) {
-      logger.info("No active sessions found, creating new ones...");
-      await client.createAllSessions();
+  static applyStringPattern(stringSchema, schema) {
+    if (!schema["pattern"]) {
+      return stringSchema;
     }
-    const sessions = client.getAllActiveSessions();
-    const connectors = Object.values(sessions).map(
-      (session) => session.connector
-    );
-    return adapter.createToolsFromConnectors(connectors);
+    const regex = new RegExp(schema["pattern"]);
+    return stringSchema.regex(regex, {
+      message: `String must match pattern: ${schema["pattern"]}`
+    });
   }
   /**
-   * Dynamically load tools for a specific connector.
+   * Applies length constraints to a string schema.
    *
-   * @param connector The connector to load tools for.
-   * @returns         The list of tools that were loaded in the target framework's format.
+   * @param {z.ZodString} stringSchema - The base string schema.
+   * @param {JSONSchema} schema - The JSON schema with length constraints.
+   * @returns {z.ZodString} - The updated schema with length validation.
    */
-  async loadToolsForConnector(connector) {
-    if (this.connectorToolMap.has(connector)) {
-      const cached = this.connectorToolMap.get(connector);
-      logger.debug(`Returning ${cached.length} existing tools for connector`);
-      return cached;
-    }
-    const connectorTools = [];
-    const success = await this.ensureConnectorInitialized(connector);
-    if (!success) {
-      return [];
+  static applyStringLength(stringSchema, schema) {
+    const result = stringSchema;
+    if (schema["minLength"] !== void 0) {
+      stringSchema = stringSchema.min(schema["minLength"]);
     }
-    for (const tool of connector.tools) {
-      const converted = this.convertTool(tool, connector);
-      if (converted) {
-        connectorTools.push(converted);
-      }
+    if (schema["maxLength"] !== void 0) {
+      stringSchema = stringSchema.max(schema["maxLength"]);
     }
-    this.connectorToolMap.set(connector, connectorTools);
-    logger.debug(
-      `Loaded ${connectorTools.length} new tools for connector: ${connectorTools.map((t) => t?.name ?? String(t)).join(", ")}`
-    );
-    return connectorTools;
+    return result;
   }
   /**
-   * Create tools from MCP tools in all provided connectors.
+   * Applies enum validation to a string schema.
    *
-   * @param connectors List of MCP connectors to create tools from.
-   * @returns         A promise that resolves with all converted tools.
+   * @param {z.ZodString} stringSchema - The base string schema.
+   * @param {JSONSchema} schema - The JSON schema with enum.
+   * @returns {ZodTypeAny} - The updated schema with enum validation.
    */
-  async createToolsFromConnectors(connectors) {
-    const tools = [];
-    for (const connector of connectors) {
-      const connectorTools = await this.loadToolsForConnector(connector);
-      tools.push(...connectorTools);
+  static applyStringEnum(stringSchema, schema) {
+    if (!schema.enum) {
+      return stringSchema;
     }
-    logger.debug(`Available tools: ${tools.length}`);
-    return tools;
+    return stringSchema.refine((val) => schema.enum?.includes(val), {
+      message: `Value must be one of: ${schema.enum?.join(", ")}`
+    });
   }
   /**
-   * Check if a connector is initialized and has tools.
+   * Parses a JSON schema of type array and returns the corresponding Zod schema.
    *
-   * @param connector The connector to check.
-   * @returns         True if the connector is initialized and has tools, false otherwise.
+   * @param {JSONSchema} schema - The JSON schema.
+   * @returns {ZodTypeAny} - The ZodTypeAny schema.
    */
-  checkConnectorInitialized(connector) {
-    return Boolean(connector.tools && connector.tools.length);
+  static parseArray(schema) {
+    if (Array.isArray(schema.items)) {
+      const tupleSchemas = schema.items.map((item) => this.parseSchema(item));
+      return import_zod.z.union(tupleSchemas);
+    }
+    const itemSchema = schema.items ? this.parseSchema(schema.items) : import_zod.z.any();
+    const arraySchema = import_zod.z.array(itemSchema);
+    let result = arraySchema;
+    result = this.applyArrayConstraints(arraySchema, schema);
+    return result;
   }
   /**
-   * Ensure a connector is initialized.
+   * Applies constraints to an array schema.
    *
-   * @param connector The connector to initialize.
-   * @returns         True if initialization succeeded, false otherwise.
+   * @param {z.ZodArray<any>} arraySchema - The base array schema.
+   * @param {JSONSchema} schema - The JSON schema with array constraints.
+   * @returns {z.ZodTypeAny} - The updated array schema with constraints.
    */
-  async ensureConnectorInitialized(connector) {
-    if (!this.checkConnectorInitialized(connector)) {
-      logger.debug("Connector doesn't have tools, initializing it");
-      try {
-        await connector.initialize();
-        return true;
-      } catch (err) {
-        logger.error(`Error initializing connector: ${err}`);
-        return false;
-      }
+  static applyArrayConstraints(arraySchema, schema) {
+    if (schema["minItems"] !== void 0) {
+      arraySchema = arraySchema.min(schema["minItems"]);
     }
-    return true;
-  }
-};
-
-// src/adapters/langchain_adapter.ts
-function schemaToZod(schema) {
-  try {
-    return JSONSchemaToZod.convert(schema);
-  } catch (err) {
-    logger.warn(`Failed to convert JSON schema to Zod: ${err}`);
-    return import_zod2.z.any();
-  }
-}
-__name(schemaToZod, "schemaToZod");
-var LangChainAdapter = class extends BaseAdapter {
-  static {
-    __name(this, "LangChainAdapter");
-  }
-  constructor(disallowedTools = []) {
-    super(disallowedTools);
-  }
-  /**
-   * Convert a single MCP tool specification into a LangChainJS structured tool.
-   */
-  convertTool(mcpTool, connector) {
-    if (this.disallowedTools.includes(mcpTool.name)) {
-      return null;
+    if (schema["maxItems"] !== void 0) {
+      arraySchema = arraySchema.max(schema["maxItems"]);
     }
-    const argsSchema = mcpTool.inputSchema ? schemaToZod(mcpTool.inputSchema) : import_zod2.z.object({}).optional();
-    const tool = new import_tools.DynamicStructuredTool({
-      name: mcpTool.name ?? "NO NAME",
-      description: mcpTool.description ?? "",
-      // Blank is acceptable but discouraged.
-      schema: argsSchema,
-      func: /* @__PURE__ */ __name(async (input) => {
-        logger.debug(
-          `MCP tool "${mcpTool.name}" received input: ${JSON.stringify(input)}`
-        );
-        try {
-          const result = await connector.callTool(
-            mcpTool.name,
-            input
-          );
-          return JSON.stringify(result);
-        } catch (err) {
-          logger.error(`Error executing MCP tool: ${err.message}`);
-          return `Error executing MCP tool: ${String(err)}`;
-        }
-      }, "func")
-    });
-    return tool;
-  }
-};
-
-// src/agents/mcp_agent.ts
-init_logging();
-
-// src/managers/server_manager.ts
-init_logging();
-
-// src/managers/tools/acquire_active_mcp_server.ts
-var import_zod3 = require("zod");
-
-// src/managers/tools/base.ts
-var import_tools2 = require("@langchain/core/tools");
-var MCPServerTool = class extends import_tools2.StructuredTool {
-  static {
-    __name(this, "MCPServerTool");
-  }
-  name = "mcp_server_tool";
-  description = "Base tool for MCP server operations.";
-  schema;
-  _manager;
-  constructor(manager) {
-    super();
-    this._manager = manager;
-  }
-  async _call(_arg, _runManager, _parentConfig) {
-    throw new Error("Method not implemented.");
-  }
-  get manager() {
-    return this._manager;
-  }
-};
-
-// src/managers/tools/acquire_active_mcp_server.ts
-var PresentActiveServerSchema = import_zod3.z.object({});
-var AcquireActiveMCPServerTool = class extends MCPServerTool {
-  static {
-    __name(this, "AcquireActiveMCPServerTool");
-  }
-  name = "get_active_mcp_server";
-  description = "Get the currently active MCP (Model Context Protocol) server";
-  schema = PresentActiveServerSchema;
-  constructor(manager) {
-    super(manager);
-  }
-  async _call() {
-    if (!this.manager.activeServer) {
-      return `No MCP server is currently active. Use connect_to_mcp_server to connect to a server.`;
+    if (schema["uniqueItems"]) {
+      return arraySchema.refine(
+        (items) => new Set(items).size === items.length,
+        { message: "Array items must be unique" }
+      );
     }
-    return `Currently active MCP server: ${this.manager.activeServer}`;
+    return arraySchema;
   }
-};
-
-// src/managers/tools/add_server_from_config.ts
-var import_tools3 = require("@langchain/core/tools");
-var import_zod4 = require("zod");
-init_logging();
-var AddMCPServerFromConfigTool = class extends import_tools3.StructuredTool {
-  static {
-    __name(this, "AddMCPServerFromConfigTool");
+  /**
+   * Parses an object schema.
+   *
+   * @param {JSONSchema} schema - The JSON schema for an object.
+   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   */
+  static parseObject(schema) {
+    if (schema["if"] && schema["then"]) {
+      return this.parseConditional(schema);
+    }
+    const shape = {};
+    this.processObjectProperties(schema, shape);
+    return this.processAdditionalProperties(schema, import_zod.z.object(shape));
   }
-  name = "add_mcp_server_from_config";
-  description = "Adds a new MCP server to the client from a configuration object and connects to it, making its tools available.";
-  schema = import_zod4.z.object({
-    serverName: import_zod4.z.string().describe("The name for the new MCP server."),
-    serverConfig: import_zod4.z.any().describe(
-      'The configuration object for the server. This should not include the top-level "mcpServers" key.'
-    )
-  });
-  manager;
-  constructor(manager) {
-    super();
-    this.manager = manager;
+  /**
+   * Processes object properties and builds the shape object.
+   *
+   * @param {JSONSchema} schema - The JSON schema for an object.
+   * @param {Record<string, ZodTypeAny>} shape - The shape object to populate.
+   */
+  static processObjectProperties(schema, shape) {
+    const required = new Set(schema.required || []);
+    if (!schema.properties) {
+      return;
+    }
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      const zodSchema = this.parseSchema(propSchema);
+      shape[key] = required.has(key) ? zodSchema : zodSchema.optional();
+    }
   }
-  async _call({
-    serverName,
-    serverConfig
-  }) {
-    try {
-      this.manager.client.addServer(serverName, serverConfig);
-      let result = `Server '${serverName}' added to the client.`;
-      logger.debug(
-        `Connecting to new server '${serverName}' and discovering tools.`
-      );
-      const session = await this.manager.client.createSession(serverName);
-      const connector = session.connector;
-      const tools = await this.manager.adapter.createToolsFromConnectors([connector]);
-      this.manager.serverTools[serverName] = tools;
-      this.manager.initializedServers[serverName] = true;
-      this.manager.activeServer = serverName;
-      const numTools = tools.length;
-      result += ` Session created and connected. '${serverName}' is now the active server with ${numTools} tools available.`;
-      result += `
-
-${tools.map((t) => t.name).join("\n")}`;
-      logger.info(result);
-      return result;
-    } catch (e) {
-      logger.error(
-        `Failed to add or connect to server '${serverName}': ${e.message}`
+  /**
+   * Processes additionalProperties configuration.
+   *
+   * @param {JSONSchema} schema - The JSON schema for an object.
+   * @param {z.ZodObject<any, any>} objectSchema - The Zod object schema.
+   * @returns {z.ZodObject<any, any>} - The updated Zod object schema.
+   */
+  static processAdditionalProperties(schema, objectSchema) {
+    if (schema.additionalProperties === true) {
+      return objectSchema.passthrough();
+    } else if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+      const additionalPropSchema = this.parseSchema(
+        schema.additionalProperties
       );
-      return `Failed to add or connect to server '${serverName}': ${e.message}`;
+      return objectSchema.catchall(additionalPropSchema);
+    } else {
+      return objectSchema.strict();
     }
   }
-};
-
-// src/managers/tools/connect_mcp_server.ts
-var import_zod5 = require("zod");
-init_logging();
-var ConnectMCPServerSchema = import_zod5.z.object({
-  serverName: import_zod5.z.string().describe("The name of the MCP server.")
-});
-var ConnectMCPServerTool = class extends MCPServerTool {
-  static {
-    __name(this, "ConnectMCPServerTool");
+  /**
+   * Parses a conditional schema with if-then-else.
+   *
+   * @param {JSONSchema} schema - The JSON schema with conditional validation.
+   * @returns {ZodTypeAny} - The conditional Zod schema.
+   */
+  static parseConditional(schema) {
+    const zodObject = this.createBaseObjectSchema(schema);
+    const ifCondition = schema["if"];
+    const thenSchema = schema["then"];
+    const elseSchema = schema["else"];
+    return zodObject.superRefine((data, ctx) => {
+      const dataWithDefaults = this.applyDefaultValues(
+        data,
+        schema
+      );
+      if (this.matchesCondition(dataWithDefaults, ifCondition)) {
+        this.validateConditionalSchema(dataWithDefaults, thenSchema, ctx);
+      } else if (elseSchema) {
+        this.validateConditionalSchema(dataWithDefaults, elseSchema, ctx);
+      }
+    });
   }
-  name = "connect_to_mcp_server";
-  description = "Connect to a specific MCP (Model Context Protocol) server to use its tools. Use this tool to connect to a specific server and use its tools.";
-  schema = ConnectMCPServerSchema;
-  constructor(manager) {
-    super(manager);
+  /**
+   * Creates a base object schema from the given JSON schema.
+   *
+   * @param {JSONSchema} schema - The JSON schema.
+   * @returns {z.ZodObject<any, any>} - The base Zod object schema.
+   */
+  static createBaseObjectSchema(schema) {
+    const shape = {};
+    const required = new Set(schema.required || []);
+    for (const [key, value] of Object.entries(schema.properties || {})) {
+      const zodSchema = this.parseSchema(value);
+      shape[key] = required.has(key) ? zodSchema : zodSchema.optional();
+    }
+    const zodObject = import_zod.z.object(shape);
+    return this.processAdditionalProperties(schema, zodObject);
   }
-  async _call({ serverName }) {
-    const serverNames = this.manager.client.getServerNames();
-    if (!serverNames.includes(serverName)) {
-      const available = serverNames.length > 0 ? serverNames.join(", ") : "none";
-      return `Server '${serverName}' not found. Available servers: ${available}`;
+  /**
+   * Applies default values from schema properties to data object.
+   *
+   * @param {JSONValue} data - The original data object.
+   * @param {JSONSchema} schema - The schema with default values.
+   * @returns {JSONValue} - The data object with defaults applied.
+   */
+  static applyDefaultValues(data, schema) {
+    if (typeof data !== "object" || data === null) {
+      return data;
     }
-    if (this.manager.activeServer === serverName) {
-      return `Already connected to MCP server '${serverName}'`;
+    if (Array.isArray(data)) {
+      return data;
     }
-    try {
-      let session = this.manager.client.getSession(serverName);
-      logger.debug(`Using existing session for server '${serverName}'`);
-      if (!session) {
-        logger.debug(`Creating new session for server '${serverName}'`);
-        session = await this.manager.client.createSession(serverName);
-      }
-      this.manager.activeServer = serverName;
-      if (this.manager.serverTools[serverName]) {
-        const connector = session.connector;
-        const tools = await this.manager.adapter.createToolsFromConnectors([connector]);
-        this.manager.serverTools[serverName] = tools;
-        this.manager.initializedServers[serverName] = true;
+    const objectData = data;
+    const dataWithDefaults = { ...objectData };
+    if (!schema.properties) {
+      return dataWithDefaults;
+    }
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      if (!(key in dataWithDefaults) && "default" in propSchema) {
+        dataWithDefaults[key] = propSchema["default"];
       }
-      const serverTools = this.manager.serverTools[serverName] || [];
-      const numTools = serverTools.length;
-      return `Connected to MCP server '${serverName}'. ${numTools} tools are now available.`;
-    } catch (error) {
-      logger.error(
-        `Error connecting to server '${serverName}': ${String(error)}`
-      );
-      return `Failed to connect to server '${serverName}': ${String(error)}`;
     }
+    return dataWithDefaults;
   }
-};
-
-// src/managers/tools/list_mcp_servers.ts
-var import_zod6 = require("zod");
-init_logging();
-var EnumerateServersSchema = import_zod6.z.object({});
-var ListMCPServersTool = class extends MCPServerTool {
-  static {
-    __name(this, "ListMCPServersTool");
+  /**
+   * Parses a schema with combinators (oneOf, anyOf, allOf).
+   * Delegates to the appropriate combinator parser based on which combinator is present.
+   *
+   * @param {JSONSchema} schema - The JSON schema with combinators.
+   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   */
+  static parseCombinator(schema) {
+    if (schema.oneOf) {
+      return this.parseOneOf(schema.oneOf);
+    }
+    if (schema.anyOf) {
+      return this.parseAnyOf(schema.anyOf);
+    }
+    if (schema.allOf) {
+      return this.parseAllOf(schema.allOf);
+    }
+    throw new Error("Unsupported schema type");
   }
-  name = "list_mcp_servers";
-  description = `Lists all available MCP (Model Context Protocol) servers that can be connected to, along with the tools available on each server. Use this tool to discover servers and see what functionalities they offer.`;
-  schema = EnumerateServersSchema;
-  constructor(manager) {
-    super(manager);
+  /**
+   * Parses a oneOf combinator schema.
+   *
+   * @param {JSONSchema[]} schemas - Array of JSON schemas in the oneOf.
+   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   */
+  static parseOneOf(schemas) {
+    return this.createUnionFromSchemas(schemas);
   }
-  async _call() {
-    const serverNames = this.manager.client.getServerNames();
-    if (serverNames.length === 0) {
-      return `No MCP servers are currently defined.`;
+  /**
+   * Parses an anyOf combinator schema.
+   *
+   * @param {JSONSchema[]} schemas - Array of JSON schemas in the anyOf.
+   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   */
+  static parseAnyOf(schemas) {
+    return this.createUnionFromSchemas(schemas);
+  }
+  /**
+   * Creates a union from an array of schemas, handling special cases.
+   *
+   * @param {JSONSchema[]} schemas - Array of JSON schemas to create a union from.
+   * @returns {ZodTypeAny} - The union Zod schema.
+   */
+  static createUnionFromSchemas(schemas) {
+    if (schemas.length === 0) {
+      return import_zod.z.any();
     }
-    const outputLines = ["Available MCP servers:"];
-    for (const serverName of serverNames) {
-      const isActiveServer = serverName === this.manager.activeServer;
-      const activeFlag = isActiveServer ? " (ACTIVE)" : "";
-      outputLines.push(`- ${serverName}${activeFlag}`);
-      try {
-        const serverTools = this.manager.serverTools?.[serverName] ?? [];
-        const numberOfTools = Array.isArray(serverTools) ? serverTools.length : 0;
-        outputLines.push(`${numberOfTools} tools available for this server
-`);
-      } catch (error) {
-        logger.error(
-          `Unexpected error listing tools for server '${serverName}': ${String(error)}`
-        );
+    if (schemas.length === 1) {
+      return this.parseSchema(schemas[0]);
+    }
+    const zodSchemas = [];
+    for (const subSchema of schemas) {
+      if (subSchema.type === "null") {
+        zodSchemas.push(import_zod.z.null());
+      } else {
+        zodSchemas.push(this.parseSchema(subSchema));
       }
     }
-    return outputLines.join("\n");
-  }
-};
-
-// src/managers/tools/release_mcp_server_connection.ts
-var import_zod7 = require("zod");
-var ReleaseConnectionSchema = import_zod7.z.object({});
-var ReleaseMCPServerConnectionTool = class extends MCPServerTool {
-  static {
-    __name(this, "ReleaseMCPServerConnectionTool");
+    if (zodSchemas.length >= 2) {
+      return import_zod.z.union(zodSchemas);
+    } else if (zodSchemas.length === 1) {
+      return zodSchemas[0];
+    }
+    return import_zod.z.any();
   }
-  name = "disconnect_from_mcp_server";
-  description = "Disconnect from the currently active MCP (Model Context Protocol) server";
-  schema = ReleaseConnectionSchema;
-  constructor(manager) {
-    super(manager);
+  /**
+   * Parses an allOf combinator schema by merging all schemas.
+   *
+   * @param {JSONSchema[]} schemas - Array of JSON schemas in the allOf.
+   * @returns {ZodTypeAny} - The ZodTypeAny schema.
+   */
+  static parseAllOf(schemas) {
+    if (schemas.length === 0) {
+      return import_zod.z.any();
+    }
+    if (schemas.length === 1) {
+      return this.parseSchema(schemas[0]);
+    }
+    const mergedSchema = schemas.reduce(
+      (acc, currentSchema) => this.mergeSchemas(acc, currentSchema)
+    );
+    return this.parseSchema(mergedSchema);
   }
-  async _call() {
-    if (!this.manager.activeServer) {
-      return `No MCP server is currently active, so there's nothing to disconnect from.`;
+  /**
+   * Merges two JSON schemas together.
+   *
+   * @param {JSONSchema} baseSchema - The base JSON schema.
+   * @param {JSONSchema} addSchema - The JSON schema to add.
+   * @returns {JSONSchema} - The merged JSON schema
+   */
+  static mergeSchemas(baseSchema, addSchema) {
+    const merged = { ...baseSchema, ...addSchema };
+    if (baseSchema.properties && addSchema.properties) {
+      const mergedProperties = {
+        ...baseSchema.properties,
+        ...addSchema.properties
+      };
+      merged.properties = mergedProperties;
     }
-    const serverName = this.manager.activeServer;
-    this.manager.activeServer = null;
-    return `Successfully disconnected from MCP server '${serverName}'.`;
+    if (baseSchema.required && addSchema.required) {
+      const mergedRequired = [
+        .../* @__PURE__ */ new Set([...baseSchema.required, ...addSchema.required])
+      ];
+      merged.required = mergedRequired;
+    }
+    return merged;
   }
 };
 
-// src/managers/server_manager.ts
-function isEqual(a, b) {
-  if (a === b) return true;
-  if (a == null || b == null) return false;
-  if (typeof a !== typeof b) return false;
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() === b.getTime();
-  }
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    return a.every((item, index) => isEqual(item, b[index]));
-  }
-  if (typeof a === "object" && typeof b === "object") {
-    const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length) return false;
-    return keysA.every((key) => {
-      return Object.prototype.hasOwnProperty.call(b, key) && isEqual(a[key], b[key]);
-    });
-  }
-  return false;
-}
-__name(isEqual, "isEqual");
-var ServerManager = class {
+// src/adapters/langchain_adapter.ts
+var import_tools = require("@langchain/core/tools");
+var import_zod2 = require("zod");
+init_logging();
+
+// src/adapters/base.ts
+init_logging();
+var BaseAdapter = class {
   static {
-    __name(this, "ServerManager");
-  }
-  initializedServers = {};
-  serverTools = {};
-  client;
-  adapter;
-  activeServer = null;
-  overrideManagementTools;
-  constructor(client, adapter, managementTools) {
-    this.client = client;
-    this.adapter = adapter;
-    this.overrideManagementTools = managementTools;
-  }
-  setManagementTools(tools) {
-    this.overrideManagementTools = tools;
-    logger.info(
-      `Overriding default management tools with a new set of ${tools.length} tools.`
-    );
+    __name(this, "BaseAdapter");
   }
-  logState(context) {
-    const allServerNames = this.client.getServerNames();
-    const activeSessionNames = Object.keys(this.client.getAllActiveSessions());
-    if (allServerNames.length === 0) {
-      logger.info("Server Manager State: No servers configured.");
-      return;
-    }
-    const tableData = allServerNames.map((name) => ({
-      "Server Name": name,
-      Connected: activeSessionNames.includes(name) ? "\u2705" : "\u274C",
-      Initialized: this.initializedServers[name] ? "\u2705" : "\u274C",
-      "Tool Count": this.serverTools[name]?.length ?? 0,
-      Active: this.activeServer === name ? "\u2705" : "\u274C"
-    }));
-    logger.info(`Server Manager State: [${context}]`);
-    console.table(tableData);
+  /**
+   * List of tool names that should not be available.
+   */
+  disallowedTools;
+  /**
+   * Internal cache that maps a connector instance to the list of tools
+   * generated for it.
+   */
+  connectorToolMap = /* @__PURE__ */ new Map();
+  constructor(disallowedTools) {
+    this.disallowedTools = disallowedTools ?? [];
   }
-  initialize() {
-    const serverNames = this.client.getServerNames?.();
-    if (serverNames.length === 0) {
-      logger.warn("No MCP servers defined in client configuration");
+  /**
+   * Create tools from an MCPClient instance.
+   *
+   * This is the recommended way to create tools from an MCPClient, as it handles
+   * session creation and connector extraction automatically.
+   *
+   * @param client          The MCPClient to extract tools from.
+   * @param disallowedTools Optional list of tool names to exclude.
+   * @returns               A promise that resolves with a list of converted tools.
+   */
+  static async createTools(client, disallowedTools) {
+    const adapter = new this(disallowedTools);
+    if (!client.activeSessions || Object.keys(client.activeSessions).length === 0) {
+      logger.info("No active sessions found, creating new ones...");
+      await client.createAllSessions();
     }
+    const sessions = client.getAllActiveSessions();
+    const connectors = Object.values(sessions).map(
+      (session) => session.connector
+    );
+    return adapter.createToolsFromConnectors(connectors);
   }
-  async prefetchServerTools() {
-    const servers = this.client.getServerNames();
-    for (const serverName of servers) {
-      try {
-        let session = null;
-        session = this.client.getSession(serverName);
-        logger.debug(
-          `Using existing session for server '${serverName}' to prefetch tools.`
-        );
-        if (!session) {
-          session = await this.client.createSession(serverName).catch((createSessionError) => {
-            logger.warn(
-              `Could not create session for '${serverName}' during prefetch: ${createSessionError}`
-            );
-            return null;
-          });
-          logger.debug(
-            `Temporarily created session for '${serverName}' to prefetch tools.`
-          );
-        }
-        if (session) {
-          const connector = session.connector;
-          let tools = [];
-          try {
-            tools = await this.adapter.createToolsFromConnectors([connector]);
-          } catch (toolFetchError) {
-            logger.error(
-              `Failed to create tools from connector for server '${serverName}': ${toolFetchError}`
-            );
-            continue;
-          }
-          const cachedTools = this.serverTools[serverName];
-          const toolsChanged = !cachedTools || !isEqual(cachedTools, tools);
-          if (toolsChanged) {
-            this.serverTools[serverName] = tools;
-            this.initializedServers[serverName] = true;
-            logger.debug(
-              `Prefetched ${tools.length} tools for server '${serverName}'.`
-            );
-          } else {
-            logger.debug(
-              `Tools for server '${serverName}' unchanged, using cached version.`
-            );
-          }
-        }
-      } catch (outerError) {
-        logger.error(
-          `Error prefetching tools for server '${serverName}': ${outerError}`
-        );
+  /**
+   * Dynamically load tools for a specific connector.
+   *
+   * @param connector The connector to load tools for.
+   * @returns         The list of tools that were loaded in the target framework's format.
+   */
+  async loadToolsForConnector(connector) {
+    if (this.connectorToolMap.has(connector)) {
+      const cached = this.connectorToolMap.get(connector);
+      logger.debug(`Returning ${cached.length} existing tools for connector`);
+      return cached;
+    }
+    const connectorTools = [];
+    const success = await this.ensureConnectorInitialized(connector);
+    if (!success) {
+      return [];
+    }
+    for (const tool of connector.tools) {
+      const converted = this.convertTool(tool, connector);
+      if (converted) {
+        connectorTools.push(converted);
       }
     }
+    this.connectorToolMap.set(connector, connectorTools);
+    logger.debug(
+      `Loaded ${connectorTools.length} new tools for connector: ${connectorTools.map((t) => t?.name ?? String(t)).join(", ")}`
+    );
+    return connectorTools;
   }
-  get tools() {
-    if (logger.level === "debug") {
-      this.logState("Providing tools to agent");
+  /**
+   * Create tools from MCP tools in all provided connectors.
+   *
+   * @param connectors List of MCP connectors to create tools from.
+   * @returns         A promise that resolves with all converted tools.
+   */
+  async createToolsFromConnectors(connectors) {
+    const tools = [];
+    for (const connector of connectors) {
+      const connectorTools = await this.loadToolsForConnector(connector);
+      tools.push(...connectorTools);
     }
-    const managementTools = this.overrideManagementTools ?? [
-      new AddMCPServerFromConfigTool(this),
-      new ListMCPServersTool(this),
-      new ConnectMCPServerTool(this),
-      new AcquireActiveMCPServerTool(this),
-      new ReleaseMCPServerConnectionTool(this)
-    ];
-    if (this.activeServer && this.serverTools[this.activeServer]) {
-      const activeTools = this.serverTools[this.activeServer];
-      logger.debug(
-        `Adding ${activeTools.length} tools from active server '${this.activeServer}'`
-      );
-      return [...managementTools, ...activeTools];
+    logger.debug(`Available tools: ${tools.length}`);
+    return tools;
+  }
+  /**
+   * Check if a connector is initialized and has tools.
+   *
+   * @param connector The connector to check.
+   * @returns         True if the connector is initialized and has tools, false otherwise.
+   */
+  checkConnectorInitialized(connector) {
+    return Boolean(connector.tools && connector.tools.length);
+  }
+  /**
+   * Ensure a connector is initialized.
+   *
+   * @param connector The connector to initialize.
+   * @returns         True if initialization succeeded, false otherwise.
+   */
+  async ensureConnectorInitialized(connector) {
+    if (!this.checkConnectorInitialized(connector)) {
+      logger.debug("Connector doesn't have tools, initializing it");
+      try {
+        await connector.initialize();
+        return true;
+      } catch (err) {
+        logger.error(`Error initializing connector: ${err}`);
+        return false;
+      }
     }
-    return managementTools;
+    return true;
   }
 };
 
-// src/observability/index.ts
-init_langfuse();
-init_langfuse();
-
-// src/observability/manager.ts
-init_logging();
-var ObservabilityManager = class {
+// src/adapters/langchain_adapter.ts
+function schemaToZod(schema) {
+  try {
+    return JSONSchemaToZod.convert(schema);
+  } catch (err) {
+    logger.warn(`Failed to convert JSON schema to Zod: ${err}`);
+    return import_zod2.z.any();
+  }
+}
+__name(schemaToZod, "schemaToZod");
+var LangChainAdapter = class extends BaseAdapter {
   static {
-    __name(this, "ObservabilityManager");
+    __name(this, "LangChainAdapter");
   }
-  customCallbacks;
-  availableHandlers = [];
-  handlerNames = [];
-  initialized = false;
-  verbose;
-  observe;
-  agentId;
-  metadata;
-  metadataProvider;
-  tagsProvider;
-  constructor(config = {}) {
-    this.customCallbacks = config.customCallbacks;
-    this.verbose = config.verbose ?? false;
-    this.observe = config.observe ?? true;
-    this.agentId = config.agentId;
-    this.metadata = config.metadata;
-    this.metadataProvider = config.metadataProvider;
-    this.tagsProvider = config.tagsProvider;
+  constructor(disallowedTools = []) {
+    super(disallowedTools);
   }
   /**
-   * Collect all available observability handlers from configured platforms.
+   * Convert a single MCP tool specification into a LangChainJS structured tool.
    */
-  async collectAvailableHandlers() {
-    if (this.initialized) {
-      return;
+  convertTool(mcpTool, connector) {
+    if (this.disallowedTools.includes(mcpTool.name)) {
+      return null;
     }
-    try {
-      const { langfuseHandler: langfuseHandler2, langfuseInitPromise: langfuseInitPromise2 } = await Promise.resolve().then(() => (init_langfuse(), langfuse_exports));
-      if (this.agentId || this.metadata || this.metadataProvider || this.tagsProvider) {
-        const { initializeLangfuse: initializeLangfuse2 } = await Promise.resolve().then(() => (init_langfuse(), langfuse_exports));
-        await initializeLangfuse2(
-          this.agentId,
-          this.metadata,
-          this.metadataProvider,
-          this.tagsProvider
-        );
+    const argsSchema = mcpTool.inputSchema ? schemaToZod(mcpTool.inputSchema) : import_zod2.z.object({}).optional();
+    const tool = new import_tools.DynamicStructuredTool({
+      name: mcpTool.name ?? "NO NAME",
+      description: mcpTool.description ?? "",
+      // Blank is acceptable but discouraged.
+      schema: argsSchema,
+      func: /* @__PURE__ */ __name(async (input) => {
         logger.debug(
-          `ObservabilityManager: Reinitialized Langfuse with agent ID: ${this.agentId}, metadata: ${JSON.stringify(this.metadata)}`
+          `MCP tool "${mcpTool.name}" received input: ${JSON.stringify(input)}`
         );
-      } else {
-        const initPromise = langfuseInitPromise2();
-        if (initPromise) {
-          await initPromise;
+        try {
+          const result = await connector.callTool(
+            mcpTool.name,
+            input
+          );
+          return JSON.stringify(result);
+        } catch (err) {
+          logger.error(`Error executing MCP tool: ${err.message}`);
+          return `Error executing MCP tool: ${String(err)}`;
         }
-      }
-      const handler = langfuseHandler2();
-      if (handler) {
-        this.availableHandlers.push(handler);
-        this.handlerNames.push("Langfuse");
-        logger.debug("ObservabilityManager: Langfuse handler available");
-      }
-    } catch {
-      logger.debug("ObservabilityManager: Langfuse module not available");
-    }
-    this.initialized = true;
+      }, "func")
+    });
+    return tool;
   }
-  /**
-   * Get the list of callbacks to use.
-   * @returns List of callbacks - either custom callbacks if provided, or all available observability handlers.
-   */
-  async getCallbacks() {
-    if (!this.observe) {
-      logger.debug(
-        "ObservabilityManager: Observability disabled via observe=false"
-      );
-      return [];
+};
+
+// src/agents/mcp_agent.ts
+init_logging();
+
+// src/managers/server_manager.ts
+init_logging();
+
+// src/managers/tools/acquire_active_mcp_server.ts
+var import_zod3 = require("zod");
+
+// src/managers/tools/base.ts
+var import_tools2 = require("@langchain/core/tools");
+var MCPServerTool = class extends import_tools2.StructuredTool {
+  static {
+    __name(this, "MCPServerTool");
+  }
+  name = "mcp_server_tool";
+  description = "Base tool for MCP server operations.";
+  schema;
+  _manager;
+  constructor(manager) {
+    super();
+    this._manager = manager;
+  }
+  async _call(_arg, _runManager, _parentConfig) {
+    throw new Error("Method not implemented.");
+  }
+  get manager() {
+    return this._manager;
+  }
+};
+
+// src/managers/tools/acquire_active_mcp_server.ts
+var PresentActiveServerSchema = import_zod3.z.object({});
+var AcquireActiveMCPServerTool = class extends MCPServerTool {
+  static {
+    __name(this, "AcquireActiveMCPServerTool");
+  }
+  name = "get_active_mcp_server";
+  description = "Get the currently active MCP (Model Context Protocol) server";
+  schema = PresentActiveServerSchema;
+  constructor(manager) {
+    super(manager);
+  }
+  async _call() {
+    if (!this.manager.activeServer) {
+      return `No MCP server is currently active. Use connect_to_mcp_server to connect to a server.`;
     }
-    if (this.customCallbacks) {
+    return `Currently active MCP server: ${this.manager.activeServer}`;
+  }
+};
+
+// src/managers/tools/add_server_from_config.ts
+var import_tools3 = require("@langchain/core/tools");
+var import_zod4 = require("zod");
+init_logging();
+var AddMCPServerFromConfigTool = class extends import_tools3.StructuredTool {
+  static {
+    __name(this, "AddMCPServerFromConfigTool");
+  }
+  name = "add_mcp_server_from_config";
+  description = "Adds a new MCP server to the client from a configuration object and connects to it, making its tools available.";
+  schema = import_zod4.z.object({
+    serverName: import_zod4.z.string().describe("The name for the new MCP server."),
+    serverConfig: import_zod4.z.any().describe(
+      'The configuration object for the server. This should not include the top-level "mcpServers" key.'
+    )
+  });
+  manager;
+  constructor(manager) {
+    super();
+    this.manager = manager;
+  }
+  async _call({
+    serverName,
+    serverConfig
+  }) {
+    try {
+      this.manager.client.addServer(serverName, serverConfig);
+      let result = `Server '${serverName}' added to the client.`;
       logger.debug(
-        `ObservabilityManager: Using ${this.customCallbacks.length} custom callbacks`
+        `Connecting to new server '${serverName}' and discovering tools.`
       );
-      return this.customCallbacks;
-    }
-    await this.collectAvailableHandlers();
-    if (this.availableHandlers.length > 0) {
-      logger.debug(
-        `ObservabilityManager: Using ${this.availableHandlers.length} handlers`
+      const session = await this.manager.client.createSession(serverName);
+      const connector = session.connector;
+      const tools = await this.manager.adapter.createToolsFromConnectors([connector]);
+      this.manager.serverTools[serverName] = tools;
+      this.manager.initializedServers[serverName] = true;
+      this.manager.activeServer = serverName;
+      const numTools = tools.length;
+      result += ` Session created and connected. '${serverName}' is now the active server with ${numTools} tools available.`;
+      result += `
+
+${tools.map((t) => t.name).join("\n")}`;
+      logger.info(result);
+      return result;
+    } catch (e) {
+      logger.error(
+        `Failed to add or connect to server '${serverName}': ${e.message}`
       );
-    } else {
-      logger.debug("ObservabilityManager: No callbacks configured");
+      return `Failed to add or connect to server '${serverName}': ${e.message}`;
     }
-    return this.availableHandlers;
   }
-  /**
-   * Get the names of available handlers.
-   * @returns List of handler names (e.g., ["Langfuse", "Laminar"])
-   */
-  async getHandlerNames() {
-    if (!this.observe) {
-      return [];
+};
+
+// src/managers/tools/connect_mcp_server.ts
+var import_zod5 = require("zod");
+init_logging();
+var ConnectMCPServerSchema = import_zod5.z.object({
+  serverName: import_zod5.z.string().describe("The name of the MCP server.")
+});
+var ConnectMCPServerTool = class extends MCPServerTool {
+  static {
+    __name(this, "ConnectMCPServerTool");
+  }
+  name = "connect_to_mcp_server";
+  description = "Connect to a specific MCP (Model Context Protocol) server to use its tools. Use this tool to connect to a specific server and use its tools.";
+  schema = ConnectMCPServerSchema;
+  constructor(manager) {
+    super(manager);
+  }
+  async _call({ serverName }) {
+    const serverNames = this.manager.client.getServerNames();
+    if (!serverNames.includes(serverName)) {
+      const available = serverNames.length > 0 ? serverNames.join(", ") : "none";
+      return `Server '${serverName}' not found. Available servers: ${available}`;
     }
-    if (this.customCallbacks) {
-      return this.customCallbacks.map((cb) => cb.constructor.name);
+    if (this.manager.activeServer === serverName) {
+      return `Already connected to MCP server '${serverName}'`;
     }
-    await this.collectAvailableHandlers();
-    return this.handlerNames;
-  }
-  /**
-   * Check if any callbacks are available.
-   * @returns True if callbacks are available, False otherwise.
-   */
-  async hasCallbacks() {
-    if (!this.observe) {
-      return false;
+    try {
+      let session = this.manager.client.getSession(serverName);
+      logger.debug(`Using existing session for server '${serverName}'`);
+      if (!session) {
+        logger.debug(`Creating new session for server '${serverName}'`);
+        session = await this.manager.client.createSession(serverName);
+      }
+      this.manager.activeServer = serverName;
+      if (this.manager.serverTools[serverName]) {
+        const connector = session.connector;
+        const tools = await this.manager.adapter.createToolsFromConnectors([connector]);
+        this.manager.serverTools[serverName] = tools;
+        this.manager.initializedServers[serverName] = true;
+      }
+      const serverTools = this.manager.serverTools[serverName] || [];
+      const numTools = serverTools.length;
+      return `Connected to MCP server '${serverName}'. ${numTools} tools are now available.`;
+    } catch (error) {
+      logger.error(
+        `Error connecting to server '${serverName}': ${String(error)}`
+      );
+      return `Failed to connect to server '${serverName}': ${String(error)}`;
     }
-    const callbacks = await this.getCallbacks();
-    return callbacks.length > 0;
-  }
-  /**
-   * Get the current observability status including metadata and tags.
-   * @returns Object containing enabled status, callback count, handler names, metadata, and tags.
-   */
-  async getStatus() {
-    const callbacks = await this.getCallbacks();
-    const handlerNames = await this.getHandlerNames();
-    const currentMetadata = this.metadataProvider ? this.metadataProvider() : this.metadata || {};
-    const currentTags = this.tagsProvider ? this.tagsProvider() : [];
-    return {
-      enabled: this.observe && callbacks.length > 0,
-      callbackCount: callbacks.length,
-      handlerNames,
-      metadata: currentMetadata,
-      tags: currentTags
-    };
   }
-  /**
-   * Add a callback to the custom callbacks list.
-   * @param callback The callback to add.
-   */
-  addCallback(callback) {
-    if (!this.customCallbacks) {
-      this.customCallbacks = [];
-    }
-    this.customCallbacks.push(callback);
-    logger.debug(
-      `ObservabilityManager: Added custom callback: ${callback.constructor.name}`
-    );
+};
+
+// src/managers/tools/list_mcp_servers.ts
+var import_zod6 = require("zod");
+init_logging();
+var EnumerateServersSchema = import_zod6.z.object({});
+var ListMCPServersTool = class extends MCPServerTool {
+  static {
+    __name(this, "ListMCPServersTool");
   }
-  /**
-   * Clear all custom callbacks.
-   */
-  clearCallbacks() {
-    this.customCallbacks = [];
-    logger.debug("ObservabilityManager: Cleared all custom callbacks");
+  name = "list_mcp_servers";
+  description = `Lists all available MCP (Model Context Protocol) servers that can be connected to, along with the tools available on each server. Use this tool to discover servers and see what functionalities they offer.`;
+  schema = EnumerateServersSchema;
+  constructor(manager) {
+    super(manager);
   }
-  /**
-   * Flush all pending traces to observability platforms.
-   * Important for serverless environments and short-lived processes.
-   */
-  async flush() {
-    const callbacks = await this.getCallbacks();
-    for (const callback of callbacks) {
-      if ("flushAsync" in callback && typeof callback.flushAsync === "function") {
-        await callback.flushAsync();
-      }
+  async _call() {
+    const serverNames = this.manager.client.getServerNames();
+    if (serverNames.length === 0) {
+      return `No MCP servers are currently defined.`;
     }
-    logger.debug("ObservabilityManager: All traces flushed");
-  }
-  /**
-   * Shutdown all handlers gracefully (for serverless environments).
-   */
-  async shutdown() {
-    await this.flush();
-    const callbacks = await this.getCallbacks();
-    for (const callback of callbacks) {
-      if ("shutdownAsync" in callback && typeof callback.shutdownAsync === "function") {
-        await callback.shutdownAsync();
-      } else if ("shutdown" in callback && typeof callback.shutdown === "function") {
-        await callback.shutdown();
+    const outputLines = ["Available MCP servers:"];
+    for (const serverName of serverNames) {
+      const isActiveServer = serverName === this.manager.activeServer;
+      const activeFlag = isActiveServer ? " (ACTIVE)" : "";
+      outputLines.push(`- ${serverName}${activeFlag}`);
+      try {
+        const serverTools = this.manager.serverTools?.[serverName] ?? [];
+        const numberOfTools = Array.isArray(serverTools) ? serverTools.length : 0;
+        outputLines.push(`${numberOfTools} tools available for this server
+`);
+      } catch (error) {
+        logger.error(
+          `Unexpected error listing tools for server '${serverName}': ${String(error)}`
+        );
       }
     }
-    logger.debug("ObservabilityManager: All handlers shutdown");
-  }
-  /**
-   * String representation of the ObservabilityManager.
-   */
-  toString() {
-    const names = this.handlerNames;
-    if (names.length > 0) {
-      return `ObservabilityManager(handlers=${names.join(", ")})`;
-    }
-    return "ObservabilityManager(no handlers)";
+    return outputLines.join("\n");
   }
 };
 
-// src/telemetry/telemetry.ts
-var fs2 = __toESM(require("fs"), 1);
-var os = __toESM(require("os"), 1);
-var path2 = __toESM(require("path"), 1);
-var import_posthog_node = require("posthog-node");
-
-// src/server/utils/runtime.ts
-var isDeno = typeof globalThis.Deno !== "undefined";
-function generateUUID() {
-  return globalThis.crypto.randomUUID();
-}
-__name(generateUUID, "generateUUID");
-
-// src/telemetry/telemetry.ts
-init_logging();
-
-// src/telemetry/events.ts
-var BaseTelemetryEvent = class {
+// src/managers/tools/release_mcp_server_connection.ts
+var import_zod7 = require("zod");
+var ReleaseConnectionSchema = import_zod7.z.object({});
+var ReleaseMCPServerConnectionTool = class extends MCPServerTool {
   static {
-    __name(this, "BaseTelemetryEvent");
+    __name(this, "ReleaseMCPServerConnectionTool");
+  }
+  name = "disconnect_from_mcp_server";
+  description = "Disconnect from the currently active MCP (Model Context Protocol) server";
+  schema = ReleaseConnectionSchema;
+  constructor(manager) {
+    super(manager);
+  }
+  async _call() {
+    if (!this.manager.activeServer) {
+      return `No MCP server is currently active, so there's nothing to disconnect from.`;
+    }
+    const serverName = this.manager.activeServer;
+    this.manager.activeServer = null;
+    return `Successfully disconnected from MCP server '${serverName}'.`;
   }
 };
-var MCPAgentExecutionEvent = class extends BaseTelemetryEvent {
-  constructor(data) {
-    super();
-    this.data = data;
+
+// src/managers/server_manager.ts
+function isEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, index) => isEqual(item, b[index]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every((key) => {
+      return Object.prototype.hasOwnProperty.call(b, key) && isEqual(a[key], b[key]);
+    });
   }
+  return false;
+}
+__name(isEqual, "isEqual");
+var ServerManager = class {
   static {
-    __name(this, "MCPAgentExecutionEvent");
+    __name(this, "ServerManager");
   }
-  get name() {
-    return "mcp_agent_execution";
+  initializedServers = {};
+  serverTools = {};
+  client;
+  adapter;
+  activeServer = null;
+  overrideManagementTools;
+  constructor(client, adapter, managementTools) {
+    this.client = client;
+    this.adapter = adapter;
+    this.overrideManagementTools = managementTools;
   }
-  get properties() {
-    return {
-      // Core execution info
-      execution_method: this.data.executionMethod,
-      query: this.data.query,
-      query_length: this.data.query.length,
-      success: this.data.success,
-      // Agent configuration
-      model_provider: this.data.modelProvider,
-      model_name: this.data.modelName,
-      server_count: this.data.serverCount,
-      server_identifiers: this.data.serverIdentifiers,
-      total_tools_available: this.data.totalToolsAvailable,
-      tools_available_names: this.data.toolsAvailableNames,
-      max_steps_configured: this.data.maxStepsConfigured,
-      memory_enabled: this.data.memoryEnabled,
-      use_server_manager: this.data.useServerManager,
-      // Execution parameters (always include, even if null)
-      max_steps_used: this.data.maxStepsUsed,
-      manage_connector: this.data.manageConnector,
-      external_history_used: this.data.externalHistoryUsed,
-      // Execution results (always include, even if null)
-      steps_taken: this.data.stepsTaken ?? null,
-      tools_used_count: this.data.toolsUsedCount ?? null,
-      tools_used_names: this.data.toolsUsedNames ?? null,
-      response: this.data.response ?? null,
-      response_length: this.data.response ? this.data.response.length : null,
-      execution_time_ms: this.data.executionTimeMs ?? null,
-      error_type: this.data.errorType ?? null,
-      conversation_history_length: this.data.conversationHistoryLength ?? null
-    };
+  setManagementTools(tools) {
+    this.overrideManagementTools = tools;
+    logger.info(
+      `Overriding default management tools with a new set of ${tools.length} tools.`
+    );
   }
-};
-
-// src/telemetry/utils.ts
-var fs = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
-function getPackageVersion() {
-  try {
-    if (typeof __dirname === "undefined" || typeof fs === "undefined") {
-      return "unknown";
+  logState(context) {
+    const allServerNames = this.client.getServerNames();
+    const activeSessionNames = Object.keys(this.client.getAllActiveSessions());
+    if (allServerNames.length === 0) {
+      logger.info("Server Manager State: No servers configured.");
+      return;
     }
-    const packagePath = path.join(__dirname, "../../package.json");
-    const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
-    return packageJson.version || "unknown";
-  } catch {
-    return "unknown";
+    const tableData = allServerNames.map((name) => ({
+      "Server Name": name,
+      Connected: activeSessionNames.includes(name) ? "\u2705" : "\u274C",
+      Initialized: this.initializedServers[name] ? "\u2705" : "\u274C",
+      "Tool Count": this.serverTools[name]?.length ?? 0,
+      Active: this.activeServer === name ? "\u2705" : "\u274C"
+    }));
+    logger.info(`Server Manager State: [${context}]`);
+    console.table(tableData);
   }
-}
-__name(getPackageVersion, "getPackageVersion");
-function getModelProvider(llm) {
-  return llm._llm_type || llm.constructor.name.toLowerCase();
-}
-__name(getModelProvider, "getModelProvider");
-function getModelName(llm) {
-  if ("_identifyingParams" in llm) {
-    const identifyingParams = llm._identifyingParams;
-    if (typeof identifyingParams === "object" && identifyingParams !== null) {
-      for (const key of [
-        "model",
-        "modelName",
-        "model_name",
-        "modelId",
-        "model_id",
-        "deploymentName",
-        "deployment_name"
-      ]) {
-        if (key in identifyingParams) {
-          return String(identifyingParams[key]);
+  initialize() {
+    const serverNames = this.client.getServerNames?.();
+    if (serverNames.length === 0) {
+      logger.warn("No MCP servers defined in client configuration");
+    }
+  }
+  async prefetchServerTools() {
+    const servers = this.client.getServerNames();
+    for (const serverName of servers) {
+      try {
+        let session = null;
+        session = this.client.getSession(serverName);
+        logger.debug(
+          `Using existing session for server '${serverName}' to prefetch tools.`
+        );
+        if (!session) {
+          session = await this.client.createSession(serverName).catch((createSessionError) => {
+            logger.warn(
+              `Could not create session for '${serverName}' during prefetch: ${createSessionError}`
+            );
+            return null;
+          });
+          logger.debug(
+            `Temporarily created session for '${serverName}' to prefetch tools.`
+          );
+        }
+        if (session) {
+          const connector = session.connector;
+          let tools = [];
+          try {
+            tools = await this.adapter.createToolsFromConnectors([connector]);
+          } catch (toolFetchError) {
+            logger.error(
+              `Failed to create tools from connector for server '${serverName}': ${toolFetchError}`
+            );
+            continue;
+          }
+          const cachedTools = this.serverTools[serverName];
+          const toolsChanged = !cachedTools || !isEqual(cachedTools, tools);
+          if (toolsChanged) {
+            this.serverTools[serverName] = tools;
+            this.initializedServers[serverName] = true;
+            logger.debug(
+              `Prefetched ${tools.length} tools for server '${serverName}'.`
+            );
+          } else {
+            logger.debug(
+              `Tools for server '${serverName}' unchanged, using cached version.`
+            );
+          }
         }
+      } catch (outerError) {
+        logger.error(
+          `Error prefetching tools for server '${serverName}': ${outerError}`
+        );
       }
     }
   }
-  return llm.model || llm.modelName || llm.constructor.name;
-}
-__name(getModelName, "getModelName");
-function extractModelInfo(llm) {
-  return [getModelProvider(llm), getModelName(llm)];
-}
-__name(extractModelInfo, "extractModelInfo");
-
-// src/telemetry/telemetry.ts
-function isNodeJSEnvironment2() {
-  try {
-    if (typeof navigator !== "undefined" && navigator.userAgent?.includes("Cloudflare-Workers")) {
-      return false;
+  get tools() {
+    if (logger.level === "debug") {
+      this.logState("Providing tools to agent");
     }
-    if (typeof globalThis.EdgeRuntime !== "undefined" || typeof globalThis.Deno !== "undefined") {
-      return false;
+    const managementTools = this.overrideManagementTools ?? [
+      new AddMCPServerFromConfigTool(this),
+      new ListMCPServersTool(this),
+      new ConnectMCPServerTool(this),
+      new AcquireActiveMCPServerTool(this),
+      new ReleaseMCPServerConnectionTool(this)
+    ];
+    if (this.activeServer && this.serverTools[this.activeServer]) {
+      const activeTools = this.serverTools[this.activeServer];
+      logger.debug(
+        `Adding ${activeTools.length} tools from active server '${this.activeServer}'`
+      );
+      return [...managementTools, ...activeTools];
     }
-    const hasNodeGlobals = typeof process !== "undefined" && typeof process.platform !== "undefined" && typeof __dirname !== "undefined";
-    const hasNodeModules = typeof fs2 !== "undefined" && typeof os !== "undefined" && typeof fs2.existsSync === "function";
-    return hasNodeGlobals && hasNodeModules;
-  } catch {
-    return false;
+    return managementTools;
   }
-}
-__name(isNodeJSEnvironment2, "isNodeJSEnvironment");
-var ScarfEventLogger = class {
+};
+
+// src/observability/index.ts
+init_langfuse();
+init_langfuse();
+
+// src/observability/manager.ts
+init_logging();
+var ObservabilityManager = class {
   static {
-    __name(this, "ScarfEventLogger");
+    __name(this, "ObservabilityManager");
   }
-  endpoint;
-  timeout;
-  constructor(endpoint, timeout = 3e3) {
-    this.endpoint = endpoint;
-    this.timeout = timeout;
+  customCallbacks;
+  availableHandlers = [];
+  handlerNames = [];
+  initialized = false;
+  verbose;
+  observe;
+  agentId;
+  metadata;
+  metadataProvider;
+  tagsProvider;
+  constructor(config = {}) {
+    this.customCallbacks = config.customCallbacks;
+    this.verbose = config.verbose ?? false;
+    this.observe = config.observe ?? true;
+    this.agentId = config.agentId;
+    this.metadata = config.metadata;
+    this.metadataProvider = config.metadataProvider;
+    this.tagsProvider = config.tagsProvider;
   }
-  async logEvent(properties) {
+  /**
+   * Collect all available observability handlers from configured platforms.
+   */
+  async collectAvailableHandlers() {
+    if (this.initialized) {
+      return;
+    }
     try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-      const response = await fetch(this.endpoint, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(properties),
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
+      const { langfuseHandler: langfuseHandler2, langfuseInitPromise: langfuseInitPromise2 } = await Promise.resolve().then(() => (init_langfuse(), langfuse_exports));
+      if (this.agentId || this.metadata || this.metadataProvider || this.tagsProvider) {
+        const { initializeLangfuse: initializeLangfuse2 } = await Promise.resolve().then(() => (init_langfuse(), langfuse_exports));
+        await initializeLangfuse2(
+          this.agentId,
+          this.metadata,
+          this.metadataProvider,
+          this.tagsProvider
+        );
+        logger.debug(
+          `ObservabilityManager: Reinitialized Langfuse with agent ID: ${this.agentId}, metadata: ${JSON.stringify(this.metadata)}`
+        );
+      } else {
+        const initPromise = langfuseInitPromise2();
+        if (initPromise) {
+          await initPromise;
+        }
       }
-    } catch (error) {
-      logger.debug(`Failed to send Scarf event: ${error}`);
+      const handler = langfuseHandler2();
+      if (handler) {
+        this.availableHandlers.push(handler);
+        this.handlerNames.push("Langfuse");
+        logger.debug("ObservabilityManager: Langfuse handler available");
+      }
+    } catch {
+      logger.debug("ObservabilityManager: Langfuse module not available");
     }
+    this.initialized = true;
   }
-};
-function getCacheHome() {
-  if (!isNodeJSEnvironment2()) {
-    return "/tmp/mcp_use_cache";
-  }
-  const envVar = process.env.XDG_CACHE_HOME;
-  if (envVar && path2.isAbsolute(envVar)) {
-    return envVar;
-  }
-  const platform = process.platform;
-  const homeDir = os.homedir();
-  if (platform === "win32") {
-    const appdata = process.env.LOCALAPPDATA || process.env.APPDATA;
-    if (appdata) {
-      return appdata;
-    }
-    return path2.join(homeDir, "AppData", "Local");
-  } else if (platform === "darwin") {
-    return path2.join(homeDir, "Library", "Caches");
-  } else {
-    return path2.join(homeDir, ".cache");
-  }
-}
-__name(getCacheHome, "getCacheHome");
-var Telemetry = class _Telemetry {
-  static {
-    __name(this, "Telemetry");
-  }
-  static instance = null;
-  USER_ID_PATH = path2.join(
-    getCacheHome(),
-    "mcp_use_3",
-    "telemetry_user_id"
-  );
-  VERSION_DOWNLOAD_PATH = path2.join(
-    getCacheHome(),
-    "mcp_use",
-    "download_version"
-  );
-  PROJECT_API_KEY = "phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI";
-  HOST = "https://eu.i.posthog.com";
-  SCARF_GATEWAY_URL = "https://mcpuse.gateway.scarf.sh/events-ts";
-  UNKNOWN_USER_ID = "UNKNOWN_USER_ID";
-  _currUserId = null;
-  _posthogClient = null;
-  _scarfClient = null;
-  _source = "typescript";
-  constructor() {
-    const isNodeJS = isNodeJSEnvironment2();
-    const telemetryDisabled = typeof process !== "undefined" && process.env?.MCP_USE_ANONYMIZED_TELEMETRY?.toLowerCase() === "false" || false;
-    this._source = typeof process !== "undefined" && process.env?.MCP_USE_TELEMETRY_SOURCE || "typescript";
-    if (telemetryDisabled) {
-      this._posthogClient = null;
-      this._scarfClient = null;
-      logger.debug("Telemetry disabled via environment variable");
-    } else if (!isNodeJS) {
-      this._posthogClient = null;
-      this._scarfClient = null;
+  /**
+   * Get the list of callbacks to use.
+   * @returns List of callbacks - either custom callbacks if provided, or all available observability handlers.
+   */
+  async getCallbacks() {
+    if (!this.observe) {
       logger.debug(
-        "Telemetry disabled - non-Node.js environment detected (e.g., Cloudflare Workers)"
+        "ObservabilityManager: Observability disabled via observe=false"
       );
-    } else {
-      logger.info(
-        "Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable."
+      return [];
+    }
+    if (this.customCallbacks) {
+      logger.debug(
+        `ObservabilityManager: Using ${this.customCallbacks.length} custom callbacks`
       );
-      try {
-        this._posthogClient = new import_posthog_node.PostHog(this.PROJECT_API_KEY, {
-          host: this.HOST,
-          disableGeoip: false
-        });
-      } catch (e) {
-        logger.warn(`Failed to initialize PostHog telemetry: ${e}`);
-        this._posthogClient = null;
-      }
-      try {
-        this._scarfClient = new ScarfEventLogger(this.SCARF_GATEWAY_URL, 3e3);
-      } catch (e) {
-        logger.warn(`Failed to initialize Scarf telemetry: ${e}`);
-        this._scarfClient = null;
-      }
+      return this.customCallbacks;
     }
-  }
-  static getInstance() {
-    if (!_Telemetry.instance) {
-      _Telemetry.instance = new _Telemetry();
+    await this.collectAvailableHandlers();
+    if (this.availableHandlers.length > 0) {
+      logger.debug(
+        `ObservabilityManager: Using ${this.availableHandlers.length} handlers`
+      );
+    } else {
+      logger.debug("ObservabilityManager: No callbacks configured");
     }
-    return _Telemetry.instance;
+    return this.availableHandlers;
   }
   /**
-   * Set the source identifier for telemetry events.
-   * This allows tracking usage from different applications.
-   * @param source - The source identifier (e.g., "my-app", "cli", "vs-code-extension")
+   * Get the names of available handlers.
+   * @returns List of handler names (e.g., ["Langfuse", "Laminar"])
    */
-  setSource(source) {
-    this._source = source;
-    logger.debug(`Telemetry source set to: ${source}`);
+  async getHandlerNames() {
+    if (!this.observe) {
+      return [];
+    }
+    if (this.customCallbacks) {
+      return this.customCallbacks.map((cb) => cb.constructor.name);
+    }
+    await this.collectAvailableHandlers();
+    return this.handlerNames;
   }
   /**
-   * Get the current source identifier.
+   * Check if any callbacks are available.
+   * @returns True if callbacks are available, False otherwise.
    */
-  getSource() {
-    return this._source;
-  }
-  get userId() {
-    if (this._currUserId) {
-      return this._currUserId;
-    }
-    if (!isNodeJSEnvironment2()) {
-      this._currUserId = this.UNKNOWN_USER_ID;
-      return this._currUserId;
-    }
-    try {
-      const isFirstTime = !fs2.existsSync(this.USER_ID_PATH);
-      if (isFirstTime) {
-        logger.debug(`Creating user ID path: ${this.USER_ID_PATH}`);
-        fs2.mkdirSync(path2.dirname(this.USER_ID_PATH), { recursive: true });
-        const newUserId = generateUUID();
-        fs2.writeFileSync(this.USER_ID_PATH, newUserId);
-        this._currUserId = newUserId;
-        logger.debug(`User ID path created: ${this.USER_ID_PATH}`);
-      } else {
-        this._currUserId = fs2.readFileSync(this.USER_ID_PATH, "utf-8").trim();
-      }
-      this.trackPackageDownload({
-        triggered_by: "user_id_property"
-      }).catch((e) => logger.debug(`Failed to track package download: ${e}`));
-    } catch (e) {
-      logger.debug(`Failed to get/create user ID: ${e}`);
-      this._currUserId = this.UNKNOWN_USER_ID;
+  async hasCallbacks() {
+    if (!this.observe) {
+      return false;
     }
-    return this._currUserId;
+    const callbacks = await this.getCallbacks();
+    return callbacks.length > 0;
   }
-  async capture(event) {
-    if (!this._posthogClient && !this._scarfClient) {
-      return;
-    }
-    if (this._posthogClient) {
-      try {
-        const properties = { ...event.properties };
-        properties.mcp_use_version = getPackageVersion();
-        properties.language = "typescript";
-        properties.source = this._source;
-        this._posthogClient.capture({
-          distinctId: this.userId,
-          event: event.name,
-          properties
-        });
-      } catch (e) {
-        logger.debug(`Failed to track PostHog event ${event.name}: ${e}`);
-      }
-    }
-    if (this._scarfClient) {
-      try {
-        const properties = {};
-        properties.mcp_use_version = getPackageVersion();
-        properties.user_id = this.userId;
-        properties.event = event.name;
-        properties.language = "typescript";
-        properties.source = this._source;
-        await this._scarfClient.logEvent(properties);
-      } catch (e) {
-        logger.debug(`Failed to track Scarf event ${event.name}: ${e}`);
-      }
-    }
+  /**
+   * Get the current observability status including metadata and tags.
+   * @returns Object containing enabled status, callback count, handler names, metadata, and tags.
+   */
+  async getStatus() {
+    const callbacks = await this.getCallbacks();
+    const handlerNames = await this.getHandlerNames();
+    const currentMetadata = this.metadataProvider ? this.metadataProvider() : this.metadata || {};
+    const currentTags = this.tagsProvider ? this.tagsProvider() : [];
+    return {
+      enabled: this.observe && callbacks.length > 0,
+      callbackCount: callbacks.length,
+      handlerNames,
+      metadata: currentMetadata,
+      tags: currentTags
+    };
   }
-  async trackPackageDownload(properties) {
-    if (!this._scarfClient) {
-      return;
-    }
-    if (!isNodeJSEnvironment2()) {
-      return;
-    }
-    try {
-      const currentVersion = getPackageVersion();
-      let shouldTrack = false;
-      let firstDownload = false;
-      if (!fs2.existsSync(this.VERSION_DOWNLOAD_PATH)) {
-        shouldTrack = true;
-        firstDownload = true;
-        fs2.mkdirSync(path2.dirname(this.VERSION_DOWNLOAD_PATH), {
-          recursive: true
-        });
-        fs2.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
-      } else {
-        const savedVersion = fs2.readFileSync(this.VERSION_DOWNLOAD_PATH, "utf-8").trim();
-        if (currentVersion > savedVersion) {
-          shouldTrack = true;
-          firstDownload = false;
-          fs2.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
-        }
-      }
-      if (shouldTrack) {
-        logger.debug(
-          `Tracking package download event with properties: ${JSON.stringify(properties)}`
-        );
-        const eventProperties = { ...properties || {} };
-        eventProperties.mcp_use_version = currentVersion;
-        eventProperties.user_id = this.userId;
-        eventProperties.event = "package_download";
-        eventProperties.first_download = firstDownload;
-        eventProperties.language = "typescript";
-        eventProperties.source = this._source;
-        await this._scarfClient.logEvent(eventProperties);
-      }
-    } catch (e) {
-      logger.debug(`Failed to track Scarf package_download event: ${e}`);
+  /**
+   * Add a callback to the custom callbacks list.
+   * @param callback The callback to add.
+   */
+  addCallback(callback) {
+    if (!this.customCallbacks) {
+      this.customCallbacks = [];
     }
+    this.customCallbacks.push(callback);
+    logger.debug(
+      `ObservabilityManager: Added custom callback: ${callback.constructor.name}`
+    );
   }
-  async trackAgentExecution(data) {
-    const event = new MCPAgentExecutionEvent(data);
-    await this.capture(event);
+  /**
+   * Clear all custom callbacks.
+   */
+  clearCallbacks() {
+    this.customCallbacks = [];
+    logger.debug("ObservabilityManager: Cleared all custom callbacks");
   }
-  flush() {
-    if (this._posthogClient) {
-      try {
-        this._posthogClient.flush();
-        logger.debug("PostHog client telemetry queue flushed");
-      } catch (e) {
-        logger.debug(`Failed to flush PostHog client: ${e}`);
+  /**
+   * Flush all pending traces to observability platforms.
+   * Important for serverless environments and short-lived processes.
+   */
+  async flush() {
+    const callbacks = await this.getCallbacks();
+    for (const callback of callbacks) {
+      if ("flushAsync" in callback && typeof callback.flushAsync === "function") {
+        await callback.flushAsync();
       }
     }
-    if (this._scarfClient) {
-      logger.debug("Scarf telemetry events sent immediately (no flush needed)");
-    }
+    logger.debug("ObservabilityManager: All traces flushed");
   }
-  shutdown() {
-    if (this._posthogClient) {
-      try {
-        this._posthogClient.shutdown();
-        logger.debug("PostHog client shutdown successfully");
-      } catch (e) {
-        logger.debug(`Error shutting down PostHog client: ${e}`);
+  /**
+   * Shutdown all handlers gracefully (for serverless environments).
+   */
+  async shutdown() {
+    await this.flush();
+    const callbacks = await this.getCallbacks();
+    for (const callback of callbacks) {
+      if ("shutdownAsync" in callback && typeof callback.shutdownAsync === "function") {
+        await callback.shutdownAsync();
+      } else if ("shutdown" in callback && typeof callback.shutdown === "function") {
+        await callback.shutdown();
       }
     }
-    if (this._scarfClient) {
-      logger.debug("Scarf telemetry client shutdown (no action needed)");
+    logger.debug("ObservabilityManager: All handlers shutdown");
+  }
+  /**
+   * String representation of the ObservabilityManager.
+   */
+  toString() {
+    const names = this.handlerNames;
+    if (names.length > 0) {
+      return `ObservabilityManager(handlers=${names.join(", ")})`;
     }
+    return "ObservabilityManager(no handlers)";
   }
 };
 
@@ -3308,6 +3934,13 @@ var MCPAgent = class {
   static {
     __name(this, "MCPAgent");
   }
+  /**
+   * Get the mcp-use package version.
+   * Works in all environments (Node.js, browser, Cloudflare Workers, Deno, etc.)
+   */
+  static getPackageVersion() {
+    return getPackageVersion();
+  }
   llm;
   client;
   connectors;
@@ -4031,7 +4664,7 @@ var MCPAgent = class {
       const historyToUse = externalHistory ?? this.conversationHistory;
       const langchainHistory = [];
       for (const msg of historyToUse) {
-        if (this._isHumanMessageLike(msg) || this._isAIMessageLike(msg)) {
+        if (this._isHumanMessageLike(msg) || this._isAIMessageLike(msg) || this._isToolMessageLike(msg)) {
           langchainHistory.push(msg);
         }
       }
@@ -4164,9 +4797,9 @@ var MCPAgent = class {
         }
       }
       if (this.memoryEnabled) {
-        this.addToHistory(new import_langchain2.HumanMessage(query));
-        if (finalOutput) {
-          this.addToHistory(new import_langchain2.AIMessage(finalOutput));
+        const newMessages = accumulatedMessages.slice(langchainHistory.length);
+        for (const msg of newMessages) {
+          this.addToHistory(msg);
         }
       }
       if (outputSchema && finalOutput) {
@@ -4601,7 +5234,9 @@ ${formatPrompt}`
         let chunkCount = 0;
         for await (const chunk of stream) {
           chunkCount++;
-          logger.info(`Chunk ${chunkCount}: ${JSON.stringify(chunk, null, 2)}`);
+          logger.debug(
+            `Chunk ${chunkCount}: ${JSON.stringify(chunk, null, 2)}`
+          );
           if (typeof chunk === "string") {
             try {
               structuredResult = JSON.parse(chunk);
@@ -4618,7 +5253,9 @@ ${formatPrompt}`
             }
           }
           if (chunkCount % 10 === 0) {
-            logger.info(`\u{1F504} Structured output streaming: ${chunkCount} chunks`);
+            logger.debug(
+              `\u{1F504} Structured output streaming: ${chunkCount} chunks`
+            );
           }
         }
         logger.info(