@crewai-ts/core 0.1.12 → 0.2.0

package/dist/{chunk-BE4JYKSG.js → chunk-MM4ROIFG.js}

@@ -1,19 +1,12 @@
 import {
   InternalInstructor,
-  MCPConfigFetchFailedEvent,
-  MCPConnectionCompletedEvent,
-  MCPConnectionFailedEvent,
-  MCPConnectionStartedEvent,
-  MCPToolExecutionCompletedEvent,
-  MCPToolExecutionFailedEvent,
-  MCPToolExecutionStartedEvent,
   ToolSelectionErrorEvent,
   ToolUsageErrorEvent,
   ToolUsageFinishedEvent,
   ToolUsageStartedEvent,
   ToolValidateInputErrorEvent,
   crewaiEventBus
-} from "./chunk-3PVW4JKT.js";
+} from "./chunk-C43UEMCX.js";
 import {
   ToolCallHookContext,
   getAfterToolCallHooks,
@@ -21,12 +14,9 @@ import {
   runAfterToolCallHooks,
   runBeforeToolCallHooks
 } from "./chunk-LWD4QED4.js";
-
-// src/mcp.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import {
+  extractRegisteredPDFText
+} from "./chunk-SB7ADUQA.js";
 
 // src/string-utils.ts
 import { createHash } from "crypto";
@@ -1950,22 +1940,15 @@ Base64: ${encoded}`;
 };
 async function readPDFFileText(content, filename) {
   try {
-    const module = await import("pdf-parse");
-    const PDFParse = module.PDFParse;
-    const parser = new PDFParse({ data: content });
-    try {
-      const result = await parser.getText();
-      const text = result.text?.trim() ?? "";
+    const extractedText = await extractRegisteredPDFText(content, filename);
+    if (extractedText !== null) {
+      const text = extractedText.trim();
       return text.length > 0 ? text : `[PDF file with no extractable text: ${filename}]`;
-    } finally {
-      await parser.destroy?.();
     }
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("Cannot find package")) {
-      const encoded = content.toString("base64");
-      return `[Binary file: ${filename} (application/pdf)]
+    const encoded = content.toString("base64");
+    return `[Binary file: ${filename} (application/pdf)]
 Base64: ${encoded}`;
-    }
+  } catch (error) {
     return `Unable to extract text from PDF '${filename}': ${error instanceof Error ? error.message : String(error)}`;
   }
 }
@@ -2122,215 +2105,6 @@ var CacheTools = class {
     return this.hitCache(key);
   }
 };
-var MCPNativeTool = class extends BaseTool {
-  clientFactory;
-  originalToolNameValue;
-  serverNameValue;
-  constructor(optionsOrClientFactory, toolName, toolSchema = {}, serverName, originalToolName = null) {
-    const options = typeof optionsOrClientFactory === "function" ? {
-      clientFactory: optionsOrClientFactory,
-      ...toolName === void 0 ? {} : { toolName },
-      toolSchema,
-      ...serverName === void 0 ? {} : { serverName },
-      originalToolName
-    } : optionsOrClientFactory;
-    const resolvedToolName = options.toolName ?? options.tool_name;
-    const resolvedServerName = options.serverName ?? options.server_name;
-    const resolvedClientFactory = options.clientFactory ?? options.client_factory;
-    if (!resolvedToolName || !resolvedServerName || !resolvedClientFactory) {
-      throw new Error("MCPNativeTool requires clientFactory, toolName, and serverName.");
-    }
-    const schema = options.toolSchema ?? options.tool_schema ?? {};
-    super({
-      name: `${resolvedServerName}_${resolvedToolName}`,
-      description: toolSchemaDescription(schema, resolvedToolName, resolvedServerName),
-      argsSchema: toolSchemaArgs(schema)
-    });
-    this.clientFactory = resolvedClientFactory;
-    this.originalToolNameValue = options.originalToolName ?? options.original_tool_name ?? resolvedToolName;
-    this.serverNameValue = resolvedServerName;
-  }
-  get originalToolName() {
-    return this.originalToolNameValue;
-  }
-  get original_tool_name() {
-    return this.originalToolName;
-  }
-  get serverName() {
-    return this.serverNameValue;
-  }
-  get server_name() {
-    return this.serverName;
-  }
-  _run(args) {
-    return this.runAsync(args);
-  }
-  async _arun(args) {
-    return await this.runAsync(args);
-  }
-  async runAsync(args = {}) {
-    const client = this.clientFactory();
-    if (!isMCPClientLike(client)) {
-      throw new Error("MCPNativeTool clientFactory must return an MCPClient-like object.");
-    }
-    await client.connect();
-    try {
-      return stringifyToolOutput(await client.callTool(this.originalToolName, args));
-    } finally {
-      await client.disconnect();
-    }
-  }
-  async _run_async(args = {}) {
-    return await this.runAsync(args);
-  }
-};
-var MCP_WRAPPER_MAX_RETRIES = 3;
-var MCP_TOOL_EXECUTION_TIMEOUT_SECONDS = 60;
-var MCPToolWrapper = class extends BaseTool {
-  mcpServerParamsValue;
-  originalToolNameValue;
-  serverNameValue;
-  constructor(optionsOrServerParams, toolName, toolSchema = {}, serverName) {
-    const options = isMCPToolWrapperOptions(optionsOrServerParams) ? optionsOrServerParams : {
-      mcpServerParams: optionsOrServerParams,
-      ...toolName === void 0 ? {} : { toolName },
-      toolSchema,
-      ...serverName === void 0 ? {} : { serverName }
-    };
-    const params = options.mcpServerParams ?? options.mcp_server_params;
-    const resolvedToolName = options.toolName ?? options.tool_name;
-    const resolvedServerName = options.serverName ?? options.server_name;
-    if (!params || !resolvedToolName || !resolvedServerName) {
-      throw new Error("MCPToolWrapper requires mcpServerParams, toolName, and serverName.");
-    }
-    const schema = options.toolSchema ?? options.tool_schema ?? {};
-    super({
-      name: `${resolvedServerName}_${resolvedToolName}`,
-      description: toolSchemaDescription(schema, resolvedToolName, resolvedServerName),
-      argsSchema: toolSchemaArgs(schema)
-    });
-    this.mcpServerParamsValue = { ...params };
-    this.originalToolNameValue = resolvedToolName;
-    this.serverNameValue = resolvedServerName;
-  }
-  get mcpServerParams() {
-    return { ...this.mcpServerParamsValue };
-  }
-  get mcp_server_params() {
-    return this.mcpServerParams;
-  }
-  get originalToolName() {
-    return this.originalToolNameValue;
-  }
-  get original_tool_name() {
-    return this.originalToolName;
-  }
-  get serverName() {
-    return this.serverNameValue;
-  }
-  get server_name() {
-    return this.serverName;
-  }
-  _run(args) {
-    return this._run_async(args);
-  }
-  async _arun(args) {
-    return await this._run_async(args);
-  }
-  async runAsync(args = {}) {
-    return await this._execute_tool(args);
-  }
-  async _run_async(args = {}) {
-    return await this._retry_with_exponential_backoff(this._execute_tool_with_timeout.bind(this), args);
-  }
-  async _retry_with_exponential_backoff(operationFunc, args = {}) {
-    let lastError = "";
-    for (let attempt = 0; attempt < MCP_WRAPPER_MAX_RETRIES; attempt += 1) {
-      const [result, error, shouldRetry] = await this._execute_single_attempt(operationFunc, args);
-      if (result !== null) {
-        return result;
-      }
-      if (!shouldRetry) {
-        return error;
-      }
-      lastError = error;
-      if (attempt < MCP_WRAPPER_MAX_RETRIES - 1) {
-        await waitForMCPWrapperRetry(2 ** attempt);
-      }
-    }
-    return `MCP tool execution failed after ${String(MCP_WRAPPER_MAX_RETRIES)} attempts: ${lastError}`;
-  }
-  async _execute_single_attempt(operationFunc, args = {}) {
-    try {
-      return [await operationFunc(args), "", false];
-    } catch (error) {
-      const classified = classifyMCPWrapperError(error, this.originalToolName);
-      return [null, classified.message, classified.retryable];
-    }
-  }
-  async _execute_tool_with_timeout(args = {}) {
-    return await withMCPWrapperTimeout(this._execute_tool(args));
-  }
-  async _execute_tool(args = {}) {
-    return await this._do_mcp_call(args);
-  }
-  async _do_mcp_call(args = {}) {
-    const { MCPClient: MCPClient2, HTTPTransport: HTTPTransport2 } = await import("./mcp-DS7UMYAM.js");
-    const url = this.mcpServerParamsValue.url;
-    if (typeof url !== "string") {
-      throw new Error("MCPToolWrapper requires an mcpServerParams.url string.");
-    }
-    const client = new MCPClient2(new HTTPTransport2({ url }), {
-      connectTimeout: 15,
-      executionTimeout: 60,
-      discoveryTimeout: 15,
-      maxRetries: 3
-    });
-    await client.connect();
-    try {
-      return await client.callTool(this.originalToolName, args);
-    } finally {
-      await client.disconnect();
-    }
-  }
-};
-function classifyMCPWrapperError(error, toolName) {
-  const message = error instanceof Error ? error.message : stringifyToolOutput(error);
-  const lower = message.toLowerCase();
-  if (lower.includes("authentication") || lower.includes("unauthorized")) {
-    return { message: `Authentication failed for MCP server: ${message}`, retryable: false };
-  }
-  if (lower.includes("not found")) {
-    return { message: `Tool '${toolName}' not found on MCP server`, retryable: false };
-  }
-  if (lower.includes("connection") || lower.includes("network")) {
-    return { message: `Network connection failed: ${message}`, retryable: true };
-  }
-  if (lower.includes("json") || lower.includes("parsing")) {
-    return { message: `Server response parsing error: ${message}`, retryable: true };
-  }
-  return { message: `MCP execution error: ${message}`, retryable: false };
-}
-async function waitForMCPWrapperRetry(seconds) {
-  await new Promise((resolve) => {
-    setTimeout(resolve, seconds * 1e3);
-  });
-}
-async function withMCPWrapperTimeout(operation) {
-  let timeout;
-  try {
-    return await Promise.race([
-      operation,
-      new Promise((_, reject) => {
-        timeout = setTimeout(() => {
-          reject(new Error(`Connection timed out after ${String(MCP_TOOL_EXECUTION_TIMEOUT_SECONDS)} seconds`));
-        }, MCP_TOOL_EXECUTION_TIMEOUT_SECONDS * 1e3);
-      })
-    ]);
-  } finally {
-    clearTimeout(timeout);
-  }
-}
 var ToolUsageError = class extends Error {
   constructor(message) {
     super(message);
@@ -3300,56 +3074,6 @@ function inferFunctionDescription(func, name) {
   }
   return `Tool generated from function ${name}.`;
 }
-function isMCPClientLike(value) {
-  return !!value && typeof value === "object" && typeof value.connect === "function" && typeof value.disconnect === "function" && typeof value.callTool === "function";
-}
-function isMCPToolWrapperOptions(value) {
-  return "mcpServerParams" in value || "mcp_server_params" in value || "toolName" in value || "tool_name" in value || "toolSchema" in value || "tool_schema" in value || "serverName" in value || "server_name" in value;
-}
-function toolSchemaDescription(schema, toolName, serverName) {
-  return typeof schema.description === "string" && schema.description.trim() ? schema.description : `Tool ${toolName} from ${serverName}`;
-}
-function toolSchemaArgs(schema) {
-  const argsSchema = schema.argsSchema ?? schema.args_schema;
-  if (argsSchema && typeof argsSchema === "object" && !Array.isArray(argsSchema)) {
-    return argsSchema;
-  }
-  const inputSchema = schema.inputSchema ?? schema.input_schema;
-  if (!inputSchema || typeof inputSchema !== "object" || Array.isArray(inputSchema)) {
-    return {};
-  }
-  const record = inputSchema;
-  const properties = record.properties;
-  if (!properties || typeof properties !== "object" || Array.isArray(properties)) {
-    return {};
-  }
-  const required = new Set(Array.isArray(record.required) ? record.required.filter((item) => typeof item === "string") : []);
-  return Object.fromEntries(
-    Object.entries(properties).map(([name, value]) => {
-      const property = value && typeof value === "object" && !Array.isArray(value) ? value : {};
-      const spec = {
-        type: normalizeJsonSchemaType(property.type),
-        required: required.has(name)
-      };
-      if (typeof property.description === "string") {
-        spec.description = property.description;
-      }
-      if ("default" in property) {
-        spec.default = property.default;
-      }
-      return [name, spec];
-    })
-  );
-}
-function normalizeJsonSchemaType(value) {
-  if (value === "string" || value === "number" || value === "boolean" || value === "object" || value === "array") {
-    return value;
-  }
-  if (value === "integer") {
-    return "number";
-  }
-  return "unknown";
-}
 function stableStringify(value) {
   if (Array.isArray(value)) {
     return `[${value.map((item) => stableStringify(item)).join(",")}]`;
@@ -3360,1180 +3084,6 @@ function stableStringify(value) {
   return JSON.stringify(value);
 }
 
-// src/mcp.ts
-var TransportType = {
-  STDIO: "stdio",
-  HTTP: "http",
-  STREAMABLE_HTTP: "streamable-http",
-  SSE: "sse"
-};
-var MCPReadStream = Object.freeze({ kind: "MCPReadStream" });
-var MCPWriteStream = Object.freeze({ kind: "MCPWriteStream" });
-var ToolFilterContext = class {
-  agent;
-  serverName;
-  server_name;
-  runContext;
-  run_context;
-  constructor(options) {
-    this.agent = options.agent;
-    this.serverName = options.serverName ?? options.server_name ?? "";
-    this.server_name = this.serverName;
-    this.runContext = options.runContext ?? options.run_context ?? null;
-    this.run_context = this.runContext;
-  }
-};
-var ToolFilter = Object.freeze({ kind: "ToolFilter" });
-var StaticToolFilter = class {
-  allowedToolNames;
-  allowed_tool_names;
-  blockedToolNames;
-  blocked_tool_names;
-  constructor(options = {}) {
-    this.allowedToolNames = new Set(options.allowedToolNames ?? options.allowed_tool_names ?? []);
-    this.allowed_tool_names = this.allowedToolNames;
-    this.blockedToolNames = new Set(options.blockedToolNames ?? options.blocked_tool_names ?? []);
-    this.blocked_tool_names = this.blockedToolNames;
-  }
-  filter(tool) {
-    const toolName = typeof tool.name === "string" ? tool.name : "";
-    if (this.blockedToolNames.size > 0 && this.blockedToolNames.has(toolName)) {
-      return false;
-    }
-    if (this.allowedToolNames.size > 0) {
-      return this.allowedToolNames.has(toolName);
-    }
-    return true;
-  }
-  call(tool) {
-    return this.filter(tool);
-  }
-  __call__(tool) {
-    return this.filter(tool);
-  }
-};
-function createStaticToolFilter(allowedToolNames = null, blockedToolNames = null) {
-  const filter = new StaticToolFilter({ allowedToolNames, blockedToolNames });
-  return (tool) => filter.filter(tool);
-}
-var create_static_tool_filter = createStaticToolFilter;
-function createDynamicToolFilter(filterFunc) {
-  return filterFunc;
-}
-var create_dynamic_tool_filter = createDynamicToolFilter;
-var MCPServerStdio = class {
-  command;
-  args;
-  env;
-  toolFilter;
-  tool_filter;
-  cacheToolsList;
-  cache_tools_list;
-  constructor(options) {
-    this.command = options.command;
-    this.args = options.args ? [...options.args] : [];
-    this.env = options.env ? { ...options.env } : null;
-    this.toolFilter = options.toolFilter ?? options.tool_filter ?? null;
-    this.tool_filter = this.toolFilter;
-    this.cacheToolsList = options.cacheToolsList ?? options.cache_tools_list ?? false;
-    this.cache_tools_list = this.cacheToolsList;
-  }
-};
-var MCPServerHTTP = class {
-  url;
-  headers;
-  streamable;
-  toolFilter;
-  tool_filter;
-  cacheToolsList;
-  cache_tools_list;
-  constructor(options) {
-    this.url = options.url;
-    this.headers = options.headers ? { ...options.headers } : null;
-    this.streamable = options.streamable ?? true;
-    this.toolFilter = options.toolFilter ?? options.tool_filter ?? null;
-    this.tool_filter = this.toolFilter;
-    this.cacheToolsList = options.cacheToolsList ?? options.cache_tools_list ?? false;
-    this.cache_tools_list = this.cacheToolsList;
-  }
-};
-var MCPServerSSE = class {
-  url;
-  headers;
-  toolFilter;
-  tool_filter;
-  cacheToolsList;
-  cache_tools_list;
-  constructor(options) {
-    this.url = options.url;
-    this.headers = options.headers ? { ...options.headers } : null;
-    this.toolFilter = options.toolFilter ?? options.tool_filter ?? null;
-    this.tool_filter = this.toolFilter;
-    this.cacheToolsList = options.cacheToolsList ?? options.cache_tools_list ?? false;
-    this.cache_tools_list = this.cacheToolsList;
-  }
-};
-var MCPServerConfig = Object.freeze({ kind: "MCPServerConfig" });
-var BaseTransport = class {
-  readStreamValue = null;
-  writeStreamValue = null;
-  connectedValue = false;
-  sdkTransportValue = null;
-  get transport_type() {
-    return this.transportType;
-  }
-  get connected() {
-    return this.connectedValue;
-  }
-  get readStream() {
-    if (this.readStreamValue === null) {
-      throw new Error("Transport not connected. Call connect() first.");
-    }
-    return this.readStreamValue;
-  }
-  get read_stream() {
-    return this.readStream;
-  }
-  get writeStream() {
-    if (this.writeStreamValue === null) {
-      throw new Error("Transport not connected. Call connect() first.");
-    }
-    return this.writeStreamValue;
-  }
-  get write_stream() {
-    return this.writeStream;
-  }
-  async connect() {
-    if (this.connectedValue) {
-      return this;
-    }
-    const transport = this.getSdkTransport();
-    await transport.start();
-    this.setStreams(transport, transport);
-    return this;
-  }
-  async disconnect() {
-    const transport = this.sdkTransportValue;
-    this.clearStreams();
-    if (transport) {
-      await transport.close();
-    }
-  }
-  async aenter() {
-    return await this.connect();
-  }
-  async __aenter__() {
-    return await this.aenter();
-  }
-  async aexit(_excType = null, _excVal = null, _excTb = null) {
-    void _excType;
-    void _excVal;
-    void _excTb;
-    await this.disconnect();
-  }
-  async __aexit__(excType = null, excVal = null, excTb = null) {
-    await this.aexit(excType, excVal, excTb);
-  }
-  setStreams(read, write) {
-    this.readStreamValue = read;
-    this.writeStreamValue = write;
-    this.connectedValue = true;
-  }
-  _set_streams(read, write) {
-    this.setStreams(read, write);
-  }
-  clearStreams() {
-    this.readStreamValue = null;
-    this.writeStreamValue = null;
-    this.connectedValue = false;
-  }
-  _clear_streams() {
-    this.clearStreams();
-  }
-  markConnectedForClient() {
-    const transport = this.getSdkTransport();
-    this.setStreams(transport, transport);
-  }
-  clearConnectedForClient() {
-    this.clearStreams();
-    this.sdkTransportValue = null;
-  }
-  getSdkTransport() {
-    this.sdkTransportValue ??= this.createSdkTransport();
-    return this.sdkTransportValue;
-  }
-};
-var HTTPTransport = class extends BaseTransport {
-  url;
-  headers;
-  streamable;
-  constructor(options, headers = null, streamable = true) {
-    super();
-    if (typeof options === "string") {
-      this.url = options;
-      this.headers = headers ? { ...headers } : {};
-      this.streamable = streamable;
-    } else {
-      this.url = options.url;
-      this.headers = options.headers ? { ...options.headers } : {};
-      this.streamable = options.streamable ?? true;
-    }
-  }
-  get transportType() {
-    return this.streamable ? TransportType.STREAMABLE_HTTP : TransportType.HTTP;
-  }
-  createSdkTransport() {
-    const headers = { ...this.headers };
-    const options = Object.keys(headers).length > 0 ? { requestInit: { headers } } : void 0;
-    return new StreamableHTTPClientTransport(new URL(this.url), options);
-  }
-};
-var SSETransport = class extends BaseTransport {
-  url;
-  headers;
-  constructor(options, headers = null) {
-    super();
-    if (typeof options === "string") {
-      this.url = options;
-      this.headers = headers ? { ...headers } : {};
-    } else {
-      this.url = options.url;
-      this.headers = options.headers ? { ...options.headers } : {};
-    }
-  }
-  get transportType() {
-    return TransportType.SSE;
-  }
-  createSdkTransport() {
-    const headers = { ...this.headers };
-    const options = Object.keys(headers).length > 0 ? {
-      requestInit: { headers },
-      eventSourceInit: {
-        fetch: (url, init) => fetch(url, { ...init, headers: { ...headers, ...headersFromInit(init?.headers) } })
-      }
-    } : void 0;
-    return new SSEClientTransport(new URL(this.url), options);
-  }
-};
-var StdioTransport = class extends BaseTransport {
-  command;
-  args;
-  env;
-  constructor(options, args = null, env = null) {
-    super();
-    if (typeof options === "string") {
-      this.command = options;
-      this.args = args ? [...args] : [];
-      this.env = env ? { ...env } : {};
-    } else {
-      this.command = options.command;
-      this.args = options.args ? [...options.args] : [];
-      this.env = options.env ? { ...options.env } : {};
-    }
-  }
-  get transportType() {
-    return TransportType.STDIO;
-  }
-  createSdkTransport() {
-    return new StdioClientTransport({
-      command: this.command,
-      args: [...this.args],
-      env: { ...this.env }
-    });
-  }
-};
-function isMCPServerConfig(value) {
-  return value instanceof MCPServerStdio || value instanceof MCPServerHTTP || value instanceof MCPServerSSE;
-}
-var is_mcp_server_config = isMCPServerConfig;
-var MCP_CONNECTION_TIMEOUT = 30;
-var MCP_TOOL_EXECUTION_TIMEOUT = 30;
-var MCP_DISCOVERY_TIMEOUT = 30;
-var MCP_MAX_RETRIES = 3;
-var _MCPToolResult = class {
-  content;
-  isError;
-  is_error;
-  constructor(content, isError = false) {
-    this.content = content;
-    this.isError = isError;
-    this.is_error = isError;
-  }
-};
-var MCP_SCHEMA_CACHE_TTL_MS = 3e5;
-var mcpSchemaCache = /* @__PURE__ */ new Map();
-var MCPClient = class {
-  transport;
-  connectTimeout;
-  connect_timeout;
-  executionTimeout;
-  execution_timeout;
-  discoveryTimeout;
-  discovery_timeout;
-  maxRetries;
-  max_retries;
-  cacheToolsList;
-  cache_tools_list;
-  client = null;
-  initialized = false;
-  wasConnected = false;
-  constructor(transport, options = {}) {
-    this.transport = transport;
-    this.connectTimeout = options.connectTimeout ?? options.connect_timeout ?? MCP_CONNECTION_TIMEOUT;
-    this.connect_timeout = this.connectTimeout;
-    this.executionTimeout = options.executionTimeout ?? options.execution_timeout ?? MCP_TOOL_EXECUTION_TIMEOUT;
-    this.execution_timeout = this.executionTimeout;
-    this.discoveryTimeout = options.discoveryTimeout ?? options.discovery_timeout ?? MCP_DISCOVERY_TIMEOUT;
-    this.discovery_timeout = this.discoveryTimeout;
-    this.maxRetries = options.maxRetries ?? options.max_retries ?? MCP_MAX_RETRIES;
-    this.max_retries = this.maxRetries;
-    this.cacheToolsList = options.cacheToolsList ?? options.cache_tools_list ?? false;
-    this.cache_tools_list = this.cacheToolsList;
-  }
-  get connected() {
-    return this.initialized;
-  }
-  get session() {
-    if (!this.client || !this.initialized) {
-      throw new Error("Client not connected. Call connect() first.");
-    }
-    return this.client;
-  }
-  async connect() {
-    if (this.connected) {
-      return this;
-    }
-    const [serverName, serverUrl, transportType] = this.getServerInfo();
-    const startedAt = /* @__PURE__ */ new Date();
-    const isReconnect = this.wasConnected;
-    crewaiEventBus.emit(this, new MCPConnectionStartedEvent({
-      server_name: serverName,
-      server_url: serverUrl,
-      transport_type: transportType,
-      is_reconnect: isReconnect,
-      connect_timeout: this.connectTimeout
-    }));
-    try {
-      const client = new Client({ name: "@crewai-ts/core", version: "0.0.0" }, { capabilities: {} });
-      await withTimeout(client.connect(this.transport.getSdkTransport()), this.connectTimeout, "MCP connection timed out");
-      this.client = client;
-      this.initialized = true;
-      this.wasConnected = true;
-      this.transport.markConnectedForClient();
-      const completedAt = /* @__PURE__ */ new Date();
-      crewaiEventBus.emit(this, new MCPConnectionCompletedEvent({
-        server_name: serverName,
-        server_url: serverUrl,
-        transport_type: transportType,
-        started_at: startedAt,
-        completed_at: completedAt,
-        connection_duration_ms: completedAt.getTime() - startedAt.getTime(),
-        is_reconnect: isReconnect
-      }));
-      return this;
-    } catch (error) {
-      await this.cleanupOnError();
-      const failedAt = /* @__PURE__ */ new Date();
-      crewaiEventBus.emit(this, new MCPConnectionFailedEvent({
-        server_name: serverName,
-        server_url: serverUrl,
-        transport_type: transportType,
-        error,
-        error_type: classifyMCPError(error),
-        started_at: startedAt,
-        failed_at: failedAt
-      }));
-      throw new Error(`Failed to connect to MCP server: ${formatMCPError(error)}`, { cause: error });
-    }
-  }
-  async disconnect() {
-    if (!this.client && !this.transport.connected) {
-      return;
-    }
-    try {
-      await this.client?.close();
-    } finally {
-      this.client = null;
-      this.initialized = false;
-      this.transport.clearConnectedForClient();
-    }
-  }
-  async aenter() {
-    return await this.connect();
-  }
-  async __aenter__() {
-    return await this.aenter();
-  }
-  async aexit(_excType = null, _excVal = null, _excTb = null) {
-    void _excType;
-    void _excVal;
-    void _excTb;
-    await this.disconnect();
-  }
-  async __aexit__(excType = null, excVal = null, excTb = null) {
-    await this.aexit(excType, excVal, excTb);
-  }
-  async listTools(useCache = null) {
-    if (!this.connected) {
-      await this.connect();
-    }
-    const shouldUseCache = useCache ?? this.cacheToolsList;
-    const cacheKey = this.getCacheKey("tools");
-    if (shouldUseCache) {
-      const cached = mcpSchemaCache.get(cacheKey);
-      if (cached && Date.now() - cached.createdAt < MCP_SCHEMA_CACHE_TTL_MS) {
-        return cached.tools.map((tool) => ({ ...tool }));
-      }
-    }
-    const tools = await this.retryOperation(async () => await this.listToolsImpl(), this.discoveryTimeout);
-    if (shouldUseCache) {
-      mcpSchemaCache.set(cacheKey, { tools, createdAt: Date.now() });
-    }
-    return tools;
-  }
-  async list_tools(useCache = null) {
-    return await this.listTools(useCache);
-  }
-  async listToolsImpl() {
-    const result = await withTimeout(this.session.listTools(), this.discoveryTimeout, "MCP tool discovery timed out");
-    return result.tools.map((tool) => ({
-      name: sanitizeToolName(tool.name),
-      original_name: tool.name,
-      description: tool.description ?? "",
-      inputSchema: tool.inputSchema,
-      ...tool.outputSchema ? { outputSchema: tool.outputSchema } : {},
-      ...tool.annotations ? { annotations: tool.annotations } : {}
-    }));
-  }
-  async _list_tools_impl() {
-    return await this.listToolsImpl();
-  }
-  async callTool(toolName, args = null) {
-    if (!this.connected) {
-      await this.connect();
-    }
-    const cleanedArgs = cleanToolArguments(args ?? {});
-    const [serverName, serverUrl, transportType] = this.getServerInfo();
-    const startedAt = /* @__PURE__ */ new Date();
-    crewaiEventBus.emit(this, new MCPToolExecutionStartedEvent({
-      server_name: serverName,
-      server_url: serverUrl,
-      transport_type: transportType,
-      tool_name: toolName,
-      tool_args: cleanedArgs
-    }));
-    try {
-      const toolResult = await this.retryOperation(
-        async () => await this.callToolImpl(toolName, cleanedArgs),
-        this.executionTimeout
-      );
-      const content = toolResult.content;
-      const finishedAt = /* @__PURE__ */ new Date();
-      if (toolResult.isError) {
-        crewaiEventBus.emit(this, new MCPToolExecutionFailedEvent({
-          server_name: serverName,
-          server_url: serverUrl,
-          transport_type: transportType,
-          tool_name: toolName,
-          tool_args: cleanedArgs,
-          error: content,
-          error_type: "tool_error",
-          started_at: startedAt,
-          failed_at: finishedAt
-        }));
-      } else {
-        crewaiEventBus.emit(this, new MCPToolExecutionCompletedEvent({
-          server_name: serverName,
-          server_url: serverUrl,
-          transport_type: transportType,
-          tool_name: toolName,
-          tool_args: cleanedArgs,
-          result: content,
-          started_at: startedAt,
-          completed_at: finishedAt,
-          execution_duration_ms: finishedAt.getTime() - startedAt.getTime()
-        }));
-      }
-      return content;
-    } catch (error) {
-      const failedAt = /* @__PURE__ */ new Date();
-      crewaiEventBus.emit(this, new MCPToolExecutionFailedEvent({
-        server_name: serverName,
-        server_url: serverUrl,
-        transport_type: transportType,
-        tool_name: toolName,
-        tool_args: cleanedArgs,
-        error,
-        error_type: classifyMCPError(error),
-        started_at: startedAt,
-        failed_at: failedAt
-      }));
-      throw error;
-    }
-  }
-  async call_tool(toolName, args = null) {
-    return await this.callTool(toolName, args);
-  }
-  cleanToolArguments(args) {
-    return cleanToolArguments(args);
-  }
-  _clean_tool_arguments(args) {
-    return this.cleanToolArguments(args);
-  }
-  async callToolImpl(toolName, args) {
-    const result = await withTimeout(
-      this.session.callTool({ name: toolName, arguments: args }),
-      this.executionTimeout,
-      "MCP tool execution timed out"
-    );
-    return new _MCPToolResult(stringifyMCPToolResult(result), isErrorMCPToolResult(result));
-  }
-  async _call_tool_impl(toolName, args) {
-    return await this.callToolImpl(toolName, args);
-  }
-  emitConnectionFailed(serverName, serverUrl, transportType, error, errorType, startedAt) {
-    crewaiEventBus.emit(this, new MCPConnectionFailedEvent({
-      server_name: serverName,
-      server_url: serverUrl,
-      transport_type: transportType,
-      error,
-      error_type: errorType,
-      started_at: startedAt,
-      failed_at: /* @__PURE__ */ new Date()
-    }));
-  }
-  _emit_connection_failed(serverName, serverUrl, transportType, error, errorType, startedAt) {
-    this.emitConnectionFailed(serverName, serverUrl, transportType, error, errorType, startedAt);
-  }
-  async listPrompts() {
-    if (!this.connected) {
-      await this.connect();
-    }
-    return await this.retryOperation(async () => await this.listPromptsImpl(), this.discoveryTimeout);
-  }
-  async listPromptsImpl() {
-    const result = await withTimeout(this.session.listPrompts(), this.discoveryTimeout, "MCP prompt discovery timed out");
-    return result.prompts.map((prompt) => ({
-      name: typeof prompt.name === "string" ? prompt.name : "",
-      description: typeof prompt.description === "string" ? prompt.description : "",
-      arguments: Array.isArray(prompt.arguments) ? prompt.arguments : []
-    }));
-  }
-  async _list_prompts_impl() {
-    return await this.listPromptsImpl();
-  }
-  async list_prompts() {
-    return await this.listPrompts();
-  }
-  async getPrompt(name, args = null) {
-    if (!this.connected) {
-      await this.connect();
-    }
-    const argumentsObject = args ?? {};
-    return await this.retryOperation(
-      async () => await this.getPromptImpl(name, argumentsObject),
-      this.executionTimeout
-    );
-  }
-  async getPromptImpl(name, args) {
-    const result = await withTimeout(
-      this.session.getPrompt({ name, arguments: args }),
-      this.executionTimeout,
-      "MCP prompt retrieval timed out"
-    );
-    const messages = isPlainRecord(result) && Array.isArray(result.messages) ? result.messages.map((message) => normalizePromptMessage(message)) : [];
-    return {
-      name,
-      messages,
-      arguments: args
-    };
-  }
-  async get_prompt(name, args = null) {
-    return await this.getPrompt(name, args);
-  }
-  async _get_prompt_impl(name, args) {
-    return await this.getPromptImpl(name, args);
-  }
-  async listResources() {
-    if (!this.connected) {
-      await this.connect();
-    }
-    const result = await this.retryOperation(async () => await this.session.listResources());
-    return result.resources.map((resource) => ({ ...resource }));
-  }
-  async list_resources() {
-    return await this.listResources();
-  }
-  async readResource(uri) {
-    if (!this.connected) {
-      await this.connect();
-    }
-    return await this.retryOperation(async () => await this.session.readResource({ uri }));
-  }
-  async read_resource(uri) {
-    return await this.readResource(uri);
-  }
-  getServerInfo() {
-    if (this.transport instanceof StdioTransport) {
-      return [[this.transport.command, ...this.transport.args].join(" "), null, this.transport.transportType];
-    }
-    if (this.transport instanceof HTTPTransport || this.transport instanceof SSETransport) {
-      return [this.transport.url, this.transport.url, this.transport.transportType];
-    }
-    return ["Unknown MCP Server", null, this.transport.transportType];
-  }
-  _get_server_info() {
-    return this.getServerInfo();
-  }
-  getCacheKey(kind) {
-    const [serverName, serverUrl, transportType] = this.getServerInfo();
-    return JSON.stringify([kind, transportType, serverName, serverUrl]);
-  }
-  _get_cache_key(kind) {
-    return this.getCacheKey(kind);
-  }
-  async retryOperation(operation, timeout = null) {
-    let lastError;
-    for (let attempt = 0; attempt < this.maxRetries; attempt += 1) {
-      try {
-        return timeout && timeout > 0 ? await withTimeout(operation(), timeout, `MCP operation timed out`) : await operation();
-      } catch (error) {
-        const errorMessage = formatMCPError(error).toLowerCase();
-        if (errorMessage.includes("authentication") || errorMessage.includes("unauthorized")) {
-          throw new Error(`Authentication failed: ${formatMCPError(error)}`, { cause: error });
-        }
-        if (errorMessage.includes("not found")) {
-          throw new Error(`Resource not found: ${formatMCPError(error)}`, { cause: error });
-        }
-        lastError = error;
-        if (attempt < this.maxRetries - 1) {
-          await delay(Math.min(100 * 2 ** attempt, 1e3));
-        }
-      }
-    }
-    throw lastError;
-  }
-  async _retry_operation(operation, timeout = null) {
-    return await this.retryOperation(operation, timeout);
-  }
-  async cleanupOnError() {
-    this.client = null;
-    this.initialized = false;
-    await this.transport.disconnect();
-  }
-  async _cleanup_on_error() {
-    await this.cleanupOnError();
-  }
-};
-var MCPToolResolver = class _MCPToolResolver {
-  agent;
-  logger;
-  clientsValue = [];
-  constructor(optionsOrAgent = {}, logger = null) {
-    if (isResolverOptions(optionsOrAgent)) {
-      this.agent = optionsOrAgent.agent;
-      this.logger = optionsOrAgent.logger ?? null;
-    } else {
-      this.agent = optionsOrAgent;
-      this.logger = logger;
-    }
-  }
-  get clients() {
-    return [...this.clientsValue];
-  }
-  async resolve(mcps) {
-    if (!mcps) {
-      return [];
-    }
-    const tools = [];
-    const ampRefs = [];
-    for (const config of mcps) {
-      if (typeof config === "string") {
-        if (config.startsWith("https://")) {
-          tools.push(...await this.resolveExternal(config));
-        } else {
-          ampRefs.push(this.parseAmpRef(config));
-        }
-        continue;
-      }
-      tools.push(...await this.resolveNative(config));
-    }
-    if (ampRefs.length > 0) {
-      const [ampTools, ampClients] = await this._resolve_amp(ampRefs);
-      tools.push(...ampTools);
-      this.clientsValue.push(...ampClients);
-    }
-    return tools;
-  }
-  async cleanup() {
-    const clients = this.clientsValue.splice(0);
-    for (const client of clients) {
-      try {
-        await client.disconnect();
-      } catch (error) {
-        this.log("error", `Error during MCP client cleanup: ${formatMCPError(error)}`);
-      }
-    }
-  }
-  async disconnectAll() {
-    await this.cleanup();
-  }
-  async _disconnect_all() {
-    await this.disconnectAll();
-  }
-  static parseAmpRef(mcpConfig) {
-    const bare = mcpConfig.startsWith("crewai-amp:") ? mcpConfig.slice("crewai-amp:".length) : mcpConfig;
-    const [slug = "", specificTool = ""] = bare.split("#", 2);
-    return [slug, specificTool || null];
-  }
-  static _parse_amp_ref(mcpConfig) {
-    return _MCPToolResolver.parseAmpRef(mcpConfig);
-  }
-  parseAmpRef(mcpConfig) {
-    return _MCPToolResolver.parseAmpRef(mcpConfig);
-  }
-  _parse_amp_ref(mcpConfig) {
-    return this.parseAmpRef(mcpConfig);
-  }
-  fetchAmpMcpConfigs(slugs) {
-    void slugs;
-    this.log("debug", "AMP MCP config fetching is not available in the local TypeScript runtime.");
-    return {};
-  }
-  _fetch_amp_mcp_configs(slugs) {
-    return this.fetchAmpMcpConfigs(slugs);
-  }
-  async resolveAmp(ampRefs) {
-    const uniqueSlugs = [...new Set(ampRefs.map(([slug]) => slug))];
-    const ampConfigs = this._fetch_amp_mcp_configs(uniqueSlugs);
-    const resolved = /* @__PURE__ */ new Map();
-    const clients = [];
-    for (const slug of uniqueSlugs) {
-      const config = ampConfigs[slug];
-      if (!isPlainRecord(config)) {
-        crewaiEventBus.emit(this, new MCPConfigFetchFailedEvent({
-          slug,
-          error: `Config for '${slug}' not found. Make sure it is connected in your account.`,
-          error_type: "not_connected"
-        }));
-        continue;
-      }
-      try {
-        const nativeResult = await this._resolve_native(this._build_mcp_config_from_dict(config));
-        resolved.set(slug, nativeResult);
-        clients.push(...nativeResult[1]);
-      } catch (error) {
-        crewaiEventBus.emit(this, new MCPConfigFetchFailedEvent({
-          slug,
-          error: formatMCPError(error),
-          error_type: "connection_failed"
-        }));
-      }
-    }
-    const tools = [];
-    for (const [slug, specificTool] of ampRefs) {
-      const cached = resolved.get(slug);
-      if (!cached) {
-        continue;
-      }
-      const [slugTools] = cached;
-      if (!specificTool) {
-        tools.push(...slugTools);
-        continue;
-      }
-      const sanitized = sanitizeToolName(specificTool);
-      tools.push(...slugTools.filter((tool) => tool.name.endsWith(`_${sanitized}`)));
-    }
-    return [tools, clients];
-  }
-  async _resolve_amp(ampRefs) {
-    return await this.resolveAmp(ampRefs);
-  }
-  async resolveNative(config) {
-    const serverName = serverNameForConfig(config);
-    const clientOptions = {
-      cacheToolsList: config.cacheToolsList,
-      cache_tools_list: config.cache_tools_list
-    };
-    const discoveryClient = new MCPClient(transportForConfig(config), clientOptions);
-    try {
-      await discoveryClient.connect();
-      const definitions = await discoveryClient.listTools();
-      const tools = [];
-      for (const definition of definitions) {
-        if (!await passesToolFilter(config, definition, this.agent)) {
-          continue;
-        }
-        const originalName = typeof definition.original_name === "string" ? definition.original_name : typeof definition.name === "string" ? definition.name : "";
-        const sanitizedName = sanitizeToolName(originalName);
-        tools.push(new MCPNativeTool({
-          clientFactory: () => new MCPClient(transportForConfig(config), clientOptions),
-          toolName: sanitizedName,
-          originalToolName: originalName,
-          toolSchema: definition,
-          serverName
-        }));
-      }
-      if (tools.length === 0) {
-        this.log("warning", `No tools discovered from MCP server '${serverName}'.`);
-      }
-      return tools;
-    } catch (error) {
-      throw new Error(`Failed to get native MCP tools: ${formatMCPError(error)}`, { cause: error });
-    } finally {
-      await discoveryClient.disconnect();
-    }
-  }
-  async _resolve_native(config) {
-    return [await this.resolveNative(config), []];
-  }
-  async resolveExternal(mcpRef) {
-    const [serverUrl, specificTool] = splitMCPRef(mcpRef);
-    const serverName = extractServerName(serverUrl);
-    const client = new MCPClient(new HTTPTransport({ url: serverUrl }));
-    try {
-      await client.connect();
-      const definitions = await client.listTools();
-      const sanitizedSpecificTool = specificTool ? sanitizeToolName(specificTool) : null;
-      return definitions.filter((definition) => {
-        const toolName = typeof definition.name === "string" ? definition.name : "";
-        return !sanitizedSpecificTool || sanitizeToolName(toolName) === sanitizedSpecificTool;
-      }).map((definition) => {
-        const originalName = typeof definition.original_name === "string" ? definition.original_name : typeof definition.name === "string" ? definition.name : "";
-        return new MCPToolWrapper({
-          mcpServerParams: { url: serverUrl },
-          toolName: sanitizeToolName(originalName),
-          toolSchema: definition,
-          serverName
-        });
-      });
-    } finally {
-      await client.disconnect();
-    }
-  }
-  async _resolve_external(mcpRef) {
-    return await this.resolveExternal(mcpRef);
-  }
-  static createTransport(config) {
-    return [transportForConfig(config), serverNameForConfig(config)];
-  }
-  static _create_transport(config) {
-    return _MCPToolResolver.createTransport(config);
-  }
-  createTransport(config) {
-    return _MCPToolResolver.createTransport(config);
-  }
-  _create_transport(config) {
-    return this.createTransport(config);
-  }
-  static buildMcpConfigFromDict(config) {
-    const type = typeof config.type === "string" ? config.type : "http";
-    const url = typeof config.url === "string" ? config.url : "";
-    const headers = isPlainRecord(config.headers) ? stringRecord(config.headers) : null;
-    const cacheToolsList = config.cache_tools_list === true || config.cacheToolsList === true;
-    if (type === "sse") {
-      return new MCPServerSSE({ url, headers, cacheToolsList });
-    }
-    return new MCPServerHTTP({
-      url,
-      headers,
-      streamable: config.streamable !== false,
-      cacheToolsList
-    });
-  }
-  static _build_mcp_config_from_dict(config) {
-    return _MCPToolResolver.buildMcpConfigFromDict(config);
-  }
-  buildMcpConfigFromDict(config) {
-    return _MCPToolResolver.buildMcpConfigFromDict(config);
-  }
-  _build_mcp_config_from_dict(config) {
-    return this.buildMcpConfigFromDict(config);
-  }
-  static extractServerName(serverUrl) {
-    return extractServerName(serverUrl);
-  }
-  static _extract_server_name(serverUrl) {
-    return extractServerName(serverUrl);
-  }
-  extractServerName(serverUrl) {
-    return extractServerName(serverUrl);
-  }
-  _extract_server_name(serverUrl) {
-    return this.extractServerName(serverUrl);
-  }
-  async setupClientAndListTools(client) {
-    if (!client.connected) {
-      await client.connect();
-    }
-    try {
-      return await client.listTools();
-    } finally {
-      await client.disconnect();
-    }
-  }
-  async _setup_client_and_list_tools(client) {
-    return await this.setupClientAndListTools(client);
-  }
-  getMcpToolSchemas(serverParams) {
-    const url = typeof serverParams.url === "string" ? serverParams.url : "";
-    if (!url) {
-      return {};
-    }
-    const cached = mcpSchemaCache.get(url);
-    if (cached && Date.now() - cached.createdAt < MCP_SCHEMA_CACHE_TTL_MS) {
-      return Object.fromEntries(cached.tools.map((tool) => [tool.name ?? "", tool]));
-    }
-    return {};
-  }
-  _get_mcp_tool_schemas(serverParams) {
-    return this.getMcpToolSchemas(serverParams);
-  }
-  async getMcpToolSchemasAsync(serverParams) {
-    return await Promise.resolve(this.getMcpToolSchemas(serverParams));
-  }
-  async _get_mcp_tool_schemas_async(serverParams) {
-    return await this.getMcpToolSchemasAsync(serverParams);
-  }
-  async retryMcpDiscovery(operation, serverUrl) {
-    return await operation(serverUrl);
-  }
-  async _retry_mcp_discovery(operation, serverUrl) {
-    return await this.retryMcpDiscovery(operation, serverUrl);
-  }
-  async attemptMcpDiscovery(operation, serverUrl) {
-    try {
-      return [await operation(serverUrl), "", false];
-    } catch (error) {
-      const message = formatMCPError(error);
-      const lower = message.toLowerCase();
-      if (lower.includes("authentication") || lower.includes("unauthorized")) {
-        return [null, `Authentication failed for MCP server: ${message}`, false];
-      }
-      if (lower.includes("connection") || lower.includes("network") || lower.includes("timeout")) {
-        return [null, `Network connection failed: ${message}`, true];
-      }
-      return [null, `MCP discovery error: ${message}`, false];
-    }
-  }
-  async _attempt_mcp_discovery(operation, serverUrl) {
-    return await this.attemptMcpDiscovery(operation, serverUrl);
-  }
-  async discoverMcpToolsWithTimeout(serverUrl) {
-    return await withTimeout(this.discoverMcpTools(serverUrl), MCP_DISCOVERY_TIMEOUT, "MCP discovery timed out");
-  }
-  async _discover_mcp_tools_with_timeout(serverUrl) {
-    return await this.discoverMcpToolsWithTimeout(serverUrl);
-  }
-  async discoverMcpTools(serverUrl) {
-    await Promise.resolve();
-    void serverUrl;
-    return {};
-  }
-  async _discover_mcp_tools(serverUrl) {
-    return await this.discoverMcpTools(serverUrl);
-  }
-  jsonSchemaToPydantic(toolName, jsonSchema) {
-    return {
-      name: `${toolName.replaceAll("-", "_").replaceAll(" ", "_")}Schema`,
-      schema: jsonSchema
-    };
-  }
-  _json_schema_to_pydantic(toolName, jsonSchema) {
-    return this.jsonSchemaToPydantic(toolName, jsonSchema);
-  }
-  log(level, message) {
-    this.logger?.log(level, message);
-  }
-};
-var mcp_schema_cache = mcpSchemaCache;
-function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-async function withTimeout(promise, timeoutSeconds, message) {
-  const timeoutRef = {};
-  try {
-    return await Promise.race([
-      promise,
-      new Promise((_resolve, reject) => {
-        timeoutRef.current = setTimeout(() => {
-          reject(new Error(`${message} after ${String(timeoutSeconds)} seconds.`));
-        }, timeoutSeconds * 1e3);
-      })
-    ]);
-  } finally {
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-    }
-  }
-}
-function cleanToolArguments(argumentsObject) {
-  const cleaned = {};
-  for (const [key, value] of Object.entries(argumentsObject)) {
-    if (value === null || value === void 0) {
-      continue;
-    }
-    if (key === "sources" && Array.isArray(value)) {
-      const sourceValues = value;
-      const sources = sourceValues.filter((item) => item !== null && item !== void 0).map((item) => typeof item === "string" ? { type: item } : item);
-      if (sources.length > 0) {
-        cleaned[key] = sources;
-      }
-      continue;
-    }
-    if (Array.isArray(value)) {
-      const listValues = value;
-      const values = listValues.filter((item) => item !== null && item !== void 0).map((item) => isPlainRecord(item) ? cleanToolArguments(item) : item).filter((item) => !isPlainRecord(item) || Object.keys(item).length > 0);
-      if (values.length > 0) {
-        cleaned[key] = values;
-      }
-      continue;
-    }
-    if (isPlainRecord(value)) {
-      const nested = cleanToolArguments(value);
-      if (Object.keys(nested).length > 0) {
-        cleaned[key] = nested;
-      }
-      continue;
-    }
-    cleaned[key] = value;
-  }
-  return cleaned;
-}
-function isPlainRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function stringRecord(value) {
-  return Object.fromEntries(
-    Object.entries(value).filter((entry) => typeof entry[1] === "string")
-  );
-}
-function stringifyMCPToolResult(result) {
-  if (isPlainRecord(result) && Array.isArray(result.content) && result.content.length > 0) {
-    const content = result.content;
-    const first = content[0];
-    if (isPlainRecord(first) && typeof first.text === "string") {
-      return first.text;
-    }
-    return stringifyUnknown(first);
-  }
-  if (isPlainRecord(result) && "toolResult" in result) {
-    return stringifyUnknown(result.toolResult);
-  }
-  return stringifyUnknown(result);
-}
-function normalizePromptMessage(message) {
-  if (!isPlainRecord(message)) {
-    return { role: "", content: message };
-  }
-  return {
-    role: typeof message.role === "string" ? message.role : "",
-    content: message.content
-  };
-}
-function stringifyUnknown(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return value.toString();
-  }
-  if (value === null || value === void 0) {
-    return "";
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return Object.prototype.toString.call(value);
-  }
-}
-function isErrorMCPToolResult(result) {
-  return isPlainRecord(result) && result.isError === true;
-}
-function classifyMCPError(error) {
-  const message = formatMCPError(error).toLowerCase();
-  if (message.includes("timeout") || message.includes("timed out")) {
-    return "timeout";
-  }
-  if (message.includes("401") || message.includes("unauthorized") || message.includes("auth")) {
-    return "authentication";
-  }
-  return "network";
-}
-function formatMCPError(error) {
-  return error instanceof Error ? error.message : stringifyUnknown(error);
-}
-function isResolverOptions(value) {
-  return !!value && typeof value === "object" && ("agent" in value || "logger" in value);
-}
-function transportForConfig(config) {
-  if (config instanceof MCPServerStdio) {
-    return new StdioTransport(config);
-  }
-  if (config instanceof MCPServerSSE) {
-    return new SSETransport(config);
-  }
-  return new HTTPTransport(config);
-}
-function serverNameForConfig(config) {
-  if (config instanceof MCPServerStdio) {
-    return sanitizeToolName([config.command, ...config.args].join("_"));
-  }
-  if (config instanceof MCPServerHTTP || config instanceof MCPServerSSE) {
-    return extractServerName(config.url);
-  }
-  return "mcp_server";
-}
-function extractServerName(url) {
-  try {
-    const parsed = new URL(url);
-    const domain = parsed.hostname.replace(/^www\./, "").replaceAll(".", "_");
-    const path = parsed.pathname.replaceAll("/", "_").replace(/^_+|_+$/g, "");
-    return sanitizeToolName(path ? `${domain}_${path}` : domain);
-  } catch {
-    return sanitizeToolName(url.split("/").filter(Boolean).at(-1) ?? "mcp_server");
-  }
-}
-function splitMCPRef(ref) {
-  const markerIndex = ref.indexOf("#");
-  if (markerIndex === -1) {
-    return [ref, null];
-  }
-  return [ref.slice(0, markerIndex), ref.slice(markerIndex + 1) || null];
-}
-async function passesToolFilter(config, definition, agent) {
-  const filter = config.toolFilter ?? config.tool_filter;
-  if (!filter) {
-    return true;
-  }
-  if (filter.length >= 2) {
-    return await filter(
-      new ToolFilterContext({ agent, serverName: serverNameForConfig(config) }),
-      definition
-    );
-  }
-  return await filter(definition);
-}
-function headersFromInit(headers) {
-  if (!headers) {
-    return {};
-  }
-  if (headers instanceof Headers) {
-    return Object.fromEntries(headers.entries());
-  }
-  if (Array.isArray(headers)) {
-    return Object.fromEntries(headers);
-  }
-  if (typeof headers === "object") {
-    return Object.fromEntries(
-      Object.entries(headers).filter((entry) => typeof entry[1] === "string")
-    );
-  }
-  return {};
-}
-
 export {
   I18N,
   getI18N,
@@ -4594,34 +3144,6 @@ export {
   coerceSecurityConfig,
   validateMetadata,
   _validate_metadata,
-  TransportType,
-  MCPReadStream,
-  MCPWriteStream,
-  ToolFilterContext,
-  ToolFilter,
-  StaticToolFilter,
-  createStaticToolFilter,
-  create_static_tool_filter,
-  createDynamicToolFilter,
-  create_dynamic_tool_filter,
-  MCPServerStdio,
-  MCPServerHTTP,
-  MCPServerSSE,
-  MCPServerConfig,
-  BaseTransport,
-  HTTPTransport,
-  SSETransport,
-  StdioTransport,
-  isMCPServerConfig,
-  is_mcp_server_config,
-  MCP_CONNECTION_TIMEOUT,
-  MCP_TOOL_EXECUTION_TIMEOUT,
-  MCP_DISCOVERY_TIMEOUT,
-  MCP_MAX_RETRIES,
-  _MCPToolResult,
-  MCPClient,
-  MCPToolResolver,
-  mcp_schema_cache,
   OPENAI_BIGGER_MODELS,
   EnvVar,
   ToolCalling,
@@ -4654,17 +3176,17 @@ export {
   DelegateWorkTool,
   AgentTools,
   CacheTools,
-  MCPNativeTool,
-  MCPToolWrapper,
   ToolUsageError,
   ToolUsage,
   createTool,
+  functionTool,
   create_tool,
   createFunctionTool,
   create_function_tool,
   _make_tool,
   _make_with_name,
   _resolve_tool_dict,
+  isToolCalling,
   normalizeToolCalling,
   aexecuteToolAndCheckFinality,
   aexecute_tool_and_check_finality,