@crewai-ts/core 0.1.0

package/dist/chunk-BE4JYKSG.js

@@ -0,0 +1,4677 @@
+import {
+  InternalInstructor,
+  MCPConfigFetchFailedEvent,
+  MCPConnectionCompletedEvent,
+  MCPConnectionFailedEvent,
+  MCPConnectionStartedEvent,
+  MCPToolExecutionCompletedEvent,
+  MCPToolExecutionFailedEvent,
+  MCPToolExecutionStartedEvent,
+  ToolSelectionErrorEvent,
+  ToolUsageErrorEvent,
+  ToolUsageFinishedEvent,
+  ToolUsageStartedEvent,
+  ToolValidateInputErrorEvent,
+  crewaiEventBus
+} from "./chunk-3PVW4JKT.js";
+import {
+  ToolCallHookContext,
+  getAfterToolCallHooks,
+  getBeforeToolCallHooks,
+  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";
+
+// src/string-utils.ts
+import { createHash } from "crypto";
+var variablePattern = /\{([A-Za-z_][A-Za-z0-9_-]*)\}/g;
+var quotePattern = /['"]+/g;
+var camelUpperLowerPattern = /([A-Z]+)([A-Z][a-z])/g;
+var camelLowerUpperPattern = /([a-z])([A-Z])/g;
+var disallowedCharsPattern = /[^a-zA-Z0-9]+/g;
+var duplicateUnderscorePattern = /_+/g;
+var maxToolNameLength = 64;
+function sanitizeToolName(name, maxLength = maxToolNameLength) {
+  let normalized = normalizeAscii(name);
+  normalized = normalized.replace(camelUpperLowerPattern, "$1_$2");
+  normalized = normalized.replace(camelLowerUpperPattern, "$1_$2");
+  normalized = normalized.toLowerCase();
+  normalized = normalized.replace(quotePattern, "");
+  normalized = normalized.replace(disallowedCharsPattern, "_");
+  normalized = normalized.replace(duplicateUnderscorePattern, "_");
+  normalized = normalized.replace(/^_+|_+$/g, "");
+  if (normalized.length > maxLength) {
+    const hash = createHash("sha256").update(normalized).digest("hex").slice(0, 8);
+    const suffix = `_${hash}`;
+    normalized = `${normalized.slice(0, maxLength - suffix.length).replace(/_+$/g, "")}${suffix}`;
+  }
+  return normalized;
+}
+var sanitize_tool_name = sanitizeToolName;
+function slugify(text, separator = "_") {
+  let normalized = normalizeAscii(text);
+  normalized = normalized.toLowerCase();
+  normalized = normalized.replace(quotePattern, "");
+  normalized = normalized.replace(disallowedCharsPattern, separator);
+  normalized = normalized.replace(_duplicate_separator_pattern(separator), separator);
+  return trimSeparator(normalized, separator);
+}
+function _duplicate_separator_pattern(separator) {
+  return new RegExp(`(?:${escapeRegExp(separator)}){2,}`, "g");
+}
+function interpolateOnly(inputString, inputs, options = {}) {
+  const strictMissing = options.strictMissing ?? true;
+  validateInterpolationInputs(inputs);
+  if (!inputString) {
+    return "";
+  }
+  if (!inputString.includes("{") && !inputString.includes("}")) {
+    return inputString;
+  }
+  if (strictMissing && Object.keys(inputs).length === 0) {
+    throw new Error("Inputs dictionary cannot be empty when interpolating variables");
+  }
+  const variables = [...inputString.matchAll(variablePattern)].map((match) => match[1]).filter((key) => Boolean(key));
+  const missingVariable = variables.find((variable) => !(variable in inputs));
+  if (strictMissing && missingVariable) {
+    throw new Error(`Template variable '${missingVariable}' not found in inputs dictionary`);
+  }
+  let result = inputString;
+  for (const variable of variables) {
+    if (!(variable in inputs)) {
+      continue;
+    }
+    result = result.replaceAll(`{${variable}}`, stringifyInterpolationValue(inputs[variable]));
+  }
+  return result;
+}
+var interpolate_only = interpolateOnly;
+function validateInterpolationInputs(inputs) {
+  for (const [key, value] of Object.entries(inputs)) {
+    try {
+      validateInterpolationValue(value);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Invalid value for key '${key}': ${message}`, { cause: error });
+    }
+  }
+}
+function _validate_type(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach(_validate_type);
+    return;
+  }
+  if (value && typeof value === "object" && isPlainObject(value)) {
+    Object.values(value).forEach(_validate_type);
+    return;
+  }
+  throw new Error(
+    `Unsupported type ${typeName(value)} in inputs. Only str, int, float, bool, dict, and list are allowed.`
+  );
+}
+var validateInterpolationValue = _validate_type;
+function stringifyInterpolationValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  if (value === null) {
+    return "None";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => pythonRepr(item)).join(", ")}]`;
+  }
+  if (value && typeof value === "object" && isPlainObject(value)) {
+    return `{${Object.entries(value).map(([key, item]) => `${pythonRepr(key)}: ${pythonRepr(item)}`).join(", ")}}`;
+  }
+  return JSON.stringify(value);
+}
+function pythonRepr(value) {
+  if (typeof value === "string") {
+    return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  if (value === null) {
+    return "None";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => pythonRepr(item)).join(", ")}]`;
+  }
+  if (value && typeof value === "object" && isPlainObject(value)) {
+    return `{${Object.entries(value).map(([key, item]) => `${pythonRepr(key)}: ${pythonRepr(item)}`).join(", ")}}`;
+  }
+  return JSON.stringify(value);
+}
+function normalizeAscii(value) {
+  const decomposed = value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "");
+  let ascii = "";
+  for (let index = 0; index < decomposed.length; index += 1) {
+    const char = decomposed[index];
+    if (char && char.charCodeAt(0) <= 127) {
+      ascii += char;
+    }
+  }
+  return ascii;
+}
+function trimSeparator(value, separator) {
+  if (!separator) {
+    return value;
+  }
+  const escapedSeparator = escapeRegExp(separator);
+  return value.replace(new RegExp(`^(?:${escapedSeparator})+|(?:${escapedSeparator})+$`, "g"), "");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isPlainObject(value) {
+  return Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null;
+}
+function typeName(value) {
+  if (value === null) {
+    return "NoneType";
+  }
+  if (value && typeof value === "object") {
+    return value.constructor.name;
+  }
+  return typeof value;
+}
+
+// src/i18n.ts
+import { readFileSync } from "fs";
+var defaultPrompts = {
+  hierarchical_manager_agent: {
+    role: "Crew Manager",
+    goal: "Manage the team to complete the task in the best way possible.",
+    backstory: [
+      "You are a seasoned manager with a knack for getting the best out of your team.",
+      "You are also known for your ability to delegate work to the right people, and to ask the right questions to get the best out of your team.",
+      "Even though you don't perform tasks by yourself, you have a lot of experience in the field, which allows you to properly evaluate the work of your team members."
+    ].join("\n")
+  },
+  slices: {
+    observation: "\nObservation:",
+    task: "\nCurrent Task: {input}\n\nBegin! This is VERY important to you, use the tools available and give your best Final Answer, your job depends on it!\n\nThought:",
+    memory: "\n\n# Memories from past conversations:\n{memory}\n\nIMPORTANT: The memories above are an automatic selection and may be INCOMPLETE. If the task involves counting, listing, or summing items (e.g. 'how many', 'total', 'list all'), you MUST use the Search memory tool with several different queries before answering -- do NOT rely solely on the memories shown above. Enumerate each distinct item you find before giving a final count.",
+    role_playing: "You are {role}. {backstory}\nYour personal goal is: {goal}",
+    tools: "\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\n{tools}\n\nIMPORTANT: Use the following format in your response:\n\n```\nThought: you should always think about what to do\nAction: the action to take, only one name of [{tool_names}], just the name, exactly as it's written.\nAction Input: the input to the action, just a simple JSON object, enclosed in curly braces, using \" to wrap keys and values.\nObservation: the result of the action\n```\n\nOnce all necessary information is gathered, return the following format:\n\n```\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n```",
+    no_tools: "",
+    task_no_tools: "\nCurrent Task: {input}\n\nProvide your complete response:",
+    native_tools: "",
+    native_task: "\nCurrent Task: {input}",
+    post_tool_reasoning: "Analyze the tool result. If requirements are met, provide the Final Answer. Otherwise, call the next tool. Deliver only the answer without meta-commentary.",
+    format: "Decide if you need a tool or can provide the final answer. Use one at a time.\nTo use a tool, use:\nThought: [reasoning]\nAction: [name from {tool_names}]\nAction Input: [JSON object]\n\nTo provide the final answer, use:\nThought: [reasoning]\nFinal Answer: [complete response]",
+    final_answer_format: "If you don't need to use any more tools, you must give your best complete final answer, make sure it satisfies the expected criteria, use the EXACT format below:\n\n```\nThought: I now can give a great answer\nFinal Answer: my best complete final answer to the task.\n\n```",
+    task_with_context: "{task}\n\nThis is the context you're working with:\n{context}",
+    expected_output: "\nThis is the expected criteria for your final answer: {expected_output}\nyou MUST return the actual complete content as the final answer, not a summary.",
+    human_feedback: "You got human feedback on your work, re-evaluate it and give a new Final Answer when ready.\n {human_feedback}",
+    formatted_task_instructions: "Format your final answer according to the following OpenAPI schema: {output_format}\n\nIMPORTANT: Preserve the original content exactly as-is. Do NOT rewrite, paraphrase, or modify the meaning of the content. Only structure it to match the schema format.\n\nDo not include the OpenAPI schema in the final output. Ensure the final output does not include any code block markers like ```json or ```python.",
+    conversation_history_instruction: "You are a member of a crew collaborating to achieve a common goal. Your task is a specific action that contributes to this larger objective. For additional context, please review the conversation history between you and the user that led to the initiation of this crew. Use any relevant information or feedback from the conversation to inform your task execution and ensure your response aligns with both the immediate task and the crew's overall goals.",
+    summarizer_system_message: "You are an expert conversation summarizer. Create comprehensive, structured summaries that preserve all critical context, tool results, decisions, and next steps. Your summaries will be used to continue conversations seamlessly after context compaction.",
+    summarize_instruction: "Analyze the following conversation and create a structured summary that preserves all information needed to continue the task seamlessly.\n\n<conversation>\n{conversation}\n</conversation>\n\nCreate a summary with these sections:\n1. **Task Overview**: What is the agent trying to accomplish?\n2. **Current State**: What has been completed so far? What step is the agent on?\n3. **Important Discoveries**: Key facts, data, tool results, or findings that must not be lost.\n4. **Next Steps**: What should the agent do next based on the conversation?\n5. **Context to Preserve**: Any specific values, names, URLs, code snippets, or details referenced in the conversation.\n\nWrap your entire summary in <summary> tags.\n\n<summary>\n[Your structured summary here]\n</summary>",
+    summary: "<summary>\n{merged_summary}\n</summary>\n\nContinue the task from where the conversation left off. The above is a structured summary of prior context.",
+    feedback_instructions: "User feedback: {feedback}\nInstructions: Use this feedback to enhance the next output iteration.\nNote: Do not respond or add commentary.",
+    lite_agent_system_prompt_with_tools: "You are {role}. {backstory}\nYour personal goal is: {goal}\n\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\n{tools}\n\nIMPORTANT: Use the following format in your response:\n\n```\nThought: you should always think about what to do\nAction: the action to take, only one name of [{tool_names}], just the name, exactly as it's written.\nAction Input: the input to the action, just a simple JSON object, enclosed in curly braces, using \" to wrap keys and values.\nObservation: the result of the action\n```\n\nOnce all necessary information is gathered, return the following format:\n\n```\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n```",
+    lite_agent_system_prompt_without_tools: "You are {role}. {backstory}\nYour personal goal is: {goal}\n\nTo give my best complete final answer to the task respond using the exact following format:\n\nThought: I now can give a great answer\nFinal Answer: Your final answer must be the great and the most complete as possible, it must be outcome described.\n\nI MUST use these formats, my job depends on it!",
+    lite_agent_response_format: "Format your final answer according to the following OpenAPI schema: {response_format}\n\nIMPORTANT: Preserve the original content exactly as-is. Do NOT rewrite, paraphrase, or modify the meaning of the content. Only structure it to match the schema format.\n\nDo not include the OpenAPI schema in the final output. Ensure the final output does not include any code block markers like ```json or ```python.",
+    knowledge_search_query: "The original query is: {task_prompt}.",
+    knowledge_search_query_system_prompt: "Your goal is to rewrite the user query so that it is optimized for retrieval from a vector database. Consider how the query will be used to find relevant documents, and aim to make it more specific and context-aware. \n\n Do not include any other text than the rewritten query, especially any preamble or postamble and only add expected output format if its relevant to the rewritten query. \n\n Focus on the key words of the intended task and to retrieve the most relevant information. \n\n There will be some extra context provided that might need to be removed such as expected_output formats structured_outputs and other instructions.",
+    human_feedback_collapse: "Based on the following human feedback, determine which outcome best matches their intent.\n\nFeedback: {feedback}\n\nPossible outcomes: {outcomes}\n\nRespond with ONLY one of the exact outcome values listed above, nothing else."
+  },
+  errors: {
+    force_final_answer_error: "You can't keep going, here is the best final answer you generated:\n\n {formatted_answer}",
+    force_final_answer: "Now it's time you MUST give your absolute best final answer. You'll ignore all previous instructions, stop using any tools, and just return your absolute BEST Final answer.",
+    agent_tool_unexisting_coworker: "\nError executing tool. coworker mentioned not found, it must be one of the following options:\n{coworkers}\n",
+    task_repeated_usage: "I tried reusing the same input, I must stop using this action input. I'll try something else instead.\n\n",
+    tool_usage_error: "I encountered an error: {error}",
+    tool_arguments_error: "Error: the Action Input is not a valid key, value dictionary.",
+    wrong_tool_name: "You tried to use the tool {tool}, but it doesn't exist. You must use one of the following tools, use one at time: {tools}.",
+    tool_usage_exception: "I encountered an error while trying to use the tool. This was the error: {error}.\n Tool {tool} accepts these inputs: {tool_inputs}",
+    agent_tool_execution_error: "Error executing task with agent '{agent_role}'. Error: {error}",
+    validation_error: "### Previous attempt failed validation: {guardrail_result_error}\n\n\n### Previous result:\n{task_output}\n\n\nTry again, making sure to address the validation error."
+  },
+  tools: {
+    delegate_work: "Delegate a specific task to one of the following coworkers: {coworkers}\nThe input to this tool should be the coworker, the task you want them to do, and ALL necessary context to execute the task, they know nothing about the task, so share absolutely everything you know, don't reference things but instead explain them.",
+    ask_question: "Ask a specific question to one of the following coworkers: {coworkers}\nThe input to this tool should be the coworker, the question you have for them, and ALL necessary context to ask the question properly, they know nothing about the question, so share absolutely everything you know, don't reference things but instead explain them.",
+    add_image: {
+      name: "Add image to content",
+      description: "See image to understand its content, you can optionally ask a question about the image",
+      default_action: "Please provide a detailed description of this image, including all visual elements, context, and any notable details you can observe."
+    },
+    recall_memory: "Search through the team's shared memory for relevant information. Pass one or more queries to search for multiple things at once. Use this when you need to find facts, decisions, preferences, or past results that may have been stored previously. IMPORTANT: For questions that require counting, summing, or listing items across multiple conversations (e.g. 'how many X', 'total Y', 'list all Z'), you MUST search multiple times with different phrasings to ensure you find ALL relevant items before giving a final count or total. Do not rely on a single search -- items may be described differently across conversations.",
+    save_to_memory: "Store one or more important facts, decisions, observations, or lessons in memory so they can be recalled later by you or other agents. Pass multiple items at once when you have several things worth remembering."
+  },
+  memory: {
+    query_system: "You analyze a query for searching memory.\nGiven the query and available scopes, output:\n1. keywords: Key entities or keywords that can be used to filter by category.\n2. suggested_scopes: Which available scopes are most relevant (empty for all).\n3. complexity: 'simple' or 'complex'.\n4. recall_queries: 1-3 short, targeted search phrases distilled from the query. Each should be a concise phrase optimized for semantic vector search. If the query is already short and focused, return it as-is in a single-item list. For long task descriptions, extract the distinct things worth searching for.\n5. time_filter: If the query references a time period (like 'last week', 'yesterday', 'in January'), return an ISO 8601 date string for the earliest relevant date (e.g. '2026-02-01'). Return null if no time constraint is implied.",
+    extract_memories_user: "Content:\n{content}\n\nExtract memory statements as described. Return structured output.",
+    query_user: "Query: {query}\n\nAvailable scopes: {available_scopes}\n{scope_desc}\n\nReturn the analysis as structured output."
+  },
+  reasoning: {
+    initial_plan: "You are {role}. Create a focused execution plan using only the essential steps needed.",
+    refine_plan: "You are {role}. Refine your plan to address the specific gap while keeping it minimal."
+  },
+  planning: {
+    system_prompt: "You are a strategic planning assistant. Create concrete, executable plans where every step produces a verifiable result.",
+    create_plan_prompt: `Create an execution plan for the following task:
+
+## Task
+{description}
+
+## Expected Output
+{expected_output}
+
+## Available Tools
+{tools}
+
+## Planning Principles
+Focus on CONCRETE, EXECUTABLE steps. Each step must clearly state WHAT ACTION to take and HOW to verify it succeeded. The number of steps should match the task complexity. Hard limit: {max_steps} steps.
+
+## Rules:
+- Each step must have a clear DONE criterion
+- Do NOT group unrelated actions: if steps can fail independently, keep them separate
+- NO standalone "thinking" or "planning" steps -- act, don't just observe
+- The last step must produce the required output
+
+After your plan, state READY or NOT READY.`,
+    synthesis_system_prompt: "You are {role}. Synthesize the completed plan steps into a clear final answer.",
+    synthesis_user_prompt: "Original task:\n{task_description}\n\nCompleted steps:\n{combined_steps}\n\nProvide the final answer based on the completed steps."
+  }
+};
+var I18N = class {
+  promptFile;
+  prompt_file;
+  prompts;
+  constructor(options = {}) {
+    this.promptFile = options.promptFile ?? options.prompt_file ?? null;
+    this.prompt_file = this.promptFile;
+    this.prompts = options.prompts ?? (this.promptFile ? loadPromptCatalog(this.promptFile) : defaultPrompts);
+  }
+  loadPrompts() {
+    this.prompts = this.promptFile ? loadPromptCatalog(this.promptFile) : defaultPrompts;
+    return this;
+  }
+  load_prompts() {
+    return this.loadPrompts();
+  }
+  slice(slice) {
+    return this.retrieveString("slices", slice);
+  }
+  errors(error) {
+    return this.retrieveString("errors", error);
+  }
+  tools(tool) {
+    return this.retrieve("tools", tool);
+  }
+  memory(key) {
+    return this.retrieveString("memory", key);
+  }
+  retrieve(kind, key) {
+    const prompt = this.prompts[kind]?.[key];
+    if (prompt === void 0) {
+      throw new Error(`Prompt for '${kind}':'${key}'  not found.`);
+    }
+    return prompt;
+  }
+  retrieveString(kind, key) {
+    const prompt = this.retrieve(kind, key);
+    if (typeof prompt !== "string") {
+      throw new Error(`Prompt for '${kind}':'${key}' is not a string.`);
+    }
+    return prompt;
+  }
+};
+var i18nCache = /* @__PURE__ */ new Map();
+function getI18N(promptFile = null) {
+  const key = promptFile ?? "__default__";
+  const cached = i18nCache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const i18n = new I18N({ promptFile });
+  i18nCache.set(key, i18n);
+  return i18n;
+}
+function clearI18NCache() {
+  i18nCache.clear();
+}
+function loadPromptCatalog(promptFile) {
+  try {
+    const parsed = JSON.parse(readFileSync(promptFile, "utf8"));
+    if (!isPromptCatalog(parsed)) {
+      throw new Error("Prompt catalog must be an object of prompt groups.");
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error("Error decoding JSON from the prompts file.", { cause: error });
+    }
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      throw new Error(`Prompt file '${promptFile}' not found.`, { cause: error });
+    }
+    throw error;
+  }
+}
+function isPromptCatalog(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return Object.values(value).every((group) => {
+    return isRecord(group) && Object.values(group).every((entry) => {
+      return typeof entry === "string" || isRecord(entry) && Object.values(entry).every((leaf) => typeof leaf === "string");
+    });
+  });
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var I18N_DEFAULT = getI18N();
+var get_i18n = getI18N;
+var clear_i18n_cache = clearI18NCache;
+
+// src/agent-parser.ts
+var FINAL_ANSWER_ACTION = "Final Answer:";
+var MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE = "I did it wrong. Invalid Format: I missed the 'Action:' after 'Thought:'. I will do right next, and don't use a tool I have already used.\n";
+var MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE = "I did it wrong. Invalid Format: I missed the 'Action Input:' after 'Action:'. I will do right next, and don't use a tool I have already used.\n";
+var FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE = "I did it wrong. Tried to both perform Action and give a Final Answer at the same time, I must do one or the other";
+var UNABLE_TO_REPAIR_JSON_RESULTS = /* @__PURE__ */ new Set(['""', "{}"]);
+var ACTION_INPUT_REGEX = /Action\s*\d*\s*:\s*(.*?)\s*Action\s*\d*\s*Input\s*\d*\s*:\s*(.*)/s;
+var ACTION_REGEX = /Action\s*\d*\s*:\s*(.*?)/s;
+var ACTION_INPUT_ONLY_REGEX = /\s*Action\s*\d*\s*Input\s*\d*\s*:\s*(.*)/s;
+var AgentAction = class {
+  thought;
+  tool;
+  toolInput;
+  tool_input;
+  text;
+  result;
+  constructor(options) {
+    this.thought = options.thought;
+    this.tool = options.tool;
+    this.toolInput = options.toolInput ?? options.tool_input ?? "";
+    this.tool_input = this.toolInput;
+    this.text = options.text;
+    this.result = options.result ?? null;
+  }
+};
+var AgentFinish = class {
+  thought;
+  output;
+  text;
+  constructor(options) {
+    this.thought = options.thought;
+    this.output = options.output;
+    this.text = options.text;
+  }
+};
+var OutputParserError = class extends Error {
+  error;
+  constructor(error) {
+    super(error);
+    this.name = "OutputParserError";
+    this.error = error;
+  }
+};
+function parseAgentOutput(text) {
+  const thought = extractThought(text);
+  const includesAnswer = text.includes(FINAL_ANSWER_ACTION);
+  const actionMatch = ACTION_INPUT_REGEX.exec(text);
+  if (includesAnswer) {
+    let finalAnswer = text.split(FINAL_ANSWER_ACTION).at(-1)?.trim() ?? "";
+    if (finalAnswer.endsWith("```") && finalAnswer.split("```").length % 2 === 0) {
+      finalAnswer = finalAnswer.slice(0, -3).trimEnd();
+    }
+    return new AgentFinish({ thought, output: finalAnswer, text });
+  }
+  if (actionMatch) {
+    const action = actionMatch[1] ?? "";
+    const actionInput = cleanActionInput(actionMatch[2] ?? "");
+    const toolInput = actionInput.trim().replace(/^"|"$/g, "");
+    return new AgentAction({
+      thought,
+      tool: cleanAction(action),
+      toolInput: safeRepairJson(toolInput),
+      text
+    });
+  }
+  if (!ACTION_REGEX.test(text)) {
+    throw new OutputParserError(`${MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE}
+${I18N_DEFAULT.slice("final_answer_format")}`);
+  }
+  if (!ACTION_INPUT_ONLY_REGEX.test(text)) {
+    throw new OutputParserError(MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE);
+  }
+  throw new OutputParserError(I18N_DEFAULT.slice("format_without_tools"));
+}
+var parse = parseAgentOutput;
+function extractThought(text) {
+  let thoughtIndex = text.indexOf("\nAction");
+  if (thoughtIndex === -1) {
+    thoughtIndex = text.indexOf("\nFinal Answer");
+  }
+  if (thoughtIndex === -1) {
+    return "";
+  }
+  return text.slice(0, thoughtIndex).trim().replaceAll("```", "").trim();
+}
+function cleanAction(text) {
+  return text.trim().replace(/^\*+|\*+$/g, "").trim();
+}
+function cleanActionInput(text) {
+  return text.trim().replace(/^\*+\s+/, "").trim();
+}
+function safeRepairJson(toolInput) {
+  if (toolInput.startsWith("[") && toolInput.endsWith("]")) {
+    return toolInput;
+  }
+  const normalized = toolInput.replaceAll('"""', '"');
+  try {
+    const parsed = JSON.parse(normalized);
+    const repaired = JSON.stringify(parsed);
+    return UNABLE_TO_REPAIR_JSON_RESULTS.has(repaired) ? toolInput : repaired;
+  } catch {
+    return repairLooseJsonObject(normalized) ?? toolInput;
+  }
+}
+function repairLooseJsonObject(value) {
+  const trimmed = extractLooseJsonObject(value.trim());
+  if (trimmed === null) {
+    return null;
+  }
+  const withoutRawNewlines = trimmed.replaceAll(/\r?\n/g, "");
+  const withoutTrailingCommas = withoutRawNewlines.replace(/,\s*([}\]])/g, "$1");
+  const quotedKeys = withoutTrailingCommas.replace(/([{,]\s*)([A-Za-z_][\w-]*)(\s*:)/g, '$1"$2"$3');
+  const singleToDouble = quotedKeys.replace(/'([^']*)'/g, (_match, inner) => JSON.stringify(inner));
+  const withMissingColons = singleToDouble.replace(/("([^"\\]|\\.)*")\s+("([^"\\]|\\.)*")(?=\s*[,}])/g, "$1: $3");
+  const withMissingCommas = withMissingColons.replace(/("([^"\\]|\\.)*")\s+("([^"\\]|\\.)*"\s*:)/g, "$1, $3");
+  const withQuotedBareValues = withMissingCommas.replace(
+    /:\s*([^,}]*?)(\s*[,}])/g,
+    (match, raw, suffix) => {
+      const value2 = raw.trim();
+      if (value2 === "" || value2.startsWith('"') || value2.startsWith("{") || value2.startsWith("[")) {
+        return match;
+      }
+      if (/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(value2) || ["true", "false", "null"].includes(value2)) {
+        return `: ${value2}${suffix}`;
+      }
+      return `: ${JSON.stringify(value2)}${suffix}`;
+    }
+  );
+  try {
+    const parsed = JSON.parse(withQuotedBareValues);
+    return JSON.stringify(parsed);
+  } catch {
+    return null;
+  }
+}
+function extractLooseJsonObject(value) {
+  if (!value.startsWith("{")) {
+    return null;
+  }
+  let depth = 0;
+  let inString = null;
+  let escaped = false;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (inString) {
+      if (char === inString) {
+        inString = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      inString = char;
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+    } else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return value.slice(0, index + 1);
+      }
+    }
+  }
+  if (depth > 0) {
+    return `${value}${inString ?? ""}${"}".repeat(depth)}`;
+  }
+  return null;
+}
+var parse_agent_output = parseAgentOutput;
+var _extract_thought = extractThought;
+var _clean_action = cleanAction;
+var _safe_repair_json = safeRepairJson;
+
+// src/converter.ts
+var CreateConverterKwargs = class {
+  agent;
+  converterCls;
+  converter_cls;
+  llm;
+  text;
+  model;
+  instructions;
+  constructor(options) {
+    this.agent = options.agent;
+    this.converterCls = options.converterCls ?? options.converter_cls ?? Converter;
+    this.converter_cls = this.converterCls;
+    this.llm = options.llm;
+    this.text = options.text;
+    this.model = options.model;
+    this.instructions = options.instructions;
+  }
+};
+var jsonPattern = /({.*})/s;
+var ConverterError = class extends Error {
+  message;
+  constructor(message) {
+    super(message);
+    this.name = "ConverterError";
+    this.message = message;
+  }
+};
+var Converter = class {
+  llm;
+  text;
+  model;
+  instructions;
+  maxAttempts;
+  max_attempts;
+  constructor(options) {
+    this.llm = options.llm;
+    this.text = options.text;
+    this.model = options.model;
+    this.instructions = options.instructions;
+    this.maxAttempts = options.maxAttempts ?? options.max_attempts ?? 3;
+    this.max_attempts = this.maxAttempts;
+  }
+  buildMessages() {
+    return [
+      { role: "system", content: this.instructions },
+      { role: "user", content: this.text }
+    ];
+  }
+  _build_messages() {
+    return this.buildMessages();
+  }
+  async toPydantic(currentAttempt = 1) {
+    try {
+      const messages = this.buildMessages();
+      const response = supportsFunctionCalling(this.llm) ? await this.llm.call(messages, { responseModel: this.model }) : await this.llm.call(messages);
+      return this._coerce_response_to_pydantic(response);
+    } catch (error) {
+      if (currentAttempt < this.maxAttempts) {
+        return await this.toPydantic(currentAttempt + 1);
+      }
+      throw new ConverterError(`Failed to convert text into a Pydantic model due to error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  to_pydantic(currentAttempt = 1) {
+    return this.toPydantic(currentAttempt);
+  }
+  async atoPydantic(currentAttempt = 1) {
+    try {
+      const messages = this.buildMessages();
+      const response = supportsFunctionCalling(this.llm) ? await callLlmAsync(this.llm, messages, { responseModel: this.model }) : await callLlmAsync(this.llm, messages);
+      return this._coerce_response_to_pydantic(response);
+    } catch (error) {
+      if (currentAttempt < this.maxAttempts) {
+        return await this.atoPydantic(currentAttempt + 1);
+      }
+      throw new ConverterError(`Failed to convert text into a Pydantic model due to error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  ato_pydantic(currentAttempt = 1) {
+    return this.atoPydantic(currentAttempt);
+  }
+  async toJson(currentAttempt = 1) {
+    try {
+      if (supportsFunctionCalling(this.llm)) {
+        return this._create_instructor().toJson();
+      }
+      return JSON.stringify(await this.llm.call(this.buildMessages()));
+    } catch (error) {
+      if (currentAttempt < this.maxAttempts) {
+        return await this.toJson(currentAttempt + 1);
+      }
+      return new ConverterError(`Failed to convert text into JSON, error: ${error instanceof Error ? error.message : String(error)}.`);
+    }
+  }
+  to_json(currentAttempt = 1) {
+    return this.toJson(currentAttempt);
+  }
+  async atoJson(currentAttempt = 1) {
+    try {
+      if (supportsFunctionCalling(this.llm)) {
+        return await runSyncAfterAsyncTurn(() => this._create_instructor().toJson());
+      }
+      return JSON.stringify(await callLlmAsync(this.llm, this.buildMessages()));
+    } catch (error) {
+      if (currentAttempt < this.maxAttempts) {
+        return await this.atoJson(currentAttempt + 1);
+      }
+      return new ConverterError(`Failed to convert text into JSON, error: ${error instanceof Error ? error.message : String(error)}.`);
+    }
+  }
+  ato_json(currentAttempt = 1) {
+    return this.atoJson(currentAttempt);
+  }
+  _coerce_response_to_pydantic(response) {
+    return coerceResponseToModel(response, this.model);
+  }
+  _create_instructor() {
+    return new InternalInstructor(this.text, this.model, null, this.llm);
+  }
+};
+function runSyncAfterAsyncTurn(operation) {
+  return new Promise((resolve, reject) => {
+    const run = () => {
+      try {
+        resolve(operation());
+      } catch (error) {
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    };
+    if (typeof setImmediate === "function") {
+      setImmediate(run);
+      return;
+    }
+    setTimeout(run, 0);
+  });
+}
+function validateModel(result, model, isJsonOutput) {
+  const parsed = parseJsonLenient(result);
+  const validated = validateStructuredModel(parsed, model);
+  return isJsonOutput ? dumpStructuredModel(validated, model) : validated;
+}
+var validate_model = validateModel;
+function handlePartialJson(result, model, isJsonOutput, agent = null, converterClass) {
+  const match = jsonPattern.exec(result);
+  if (match?.[1]) {
+    try {
+      return validateModel(match[1], model, isJsonOutput);
+    } catch {
+      if (!agent && !converterClass) {
+        return result;
+      }
+    }
+  }
+  if (!agent && !converterClass) {
+    return result;
+  }
+  return convertWithInstructions(result, model, isJsonOutput, agent, converterClass ?? Converter);
+}
+var handle_partial_json = handlePartialJson;
+async function asyncHandlePartialJson(result, model, isJsonOutput, agent = null, converterClass) {
+  const match = jsonPattern.exec(result);
+  if (match?.[1]) {
+    try {
+      return validateModel(match[1], model, isJsonOutput);
+    } catch (error) {
+      if (!agent) {
+        return result;
+      }
+      if (error instanceof SyntaxError) {
+        return await asyncConvertWithInstructions(result, model, isJsonOutput, agent, converterClass ?? Converter);
+      }
+      throw error;
+    }
+  }
+  if (!agent) {
+    return result;
+  }
+  return await asyncConvertWithInstructions(result, model, isJsonOutput, agent, converterClass ?? Converter);
+}
+var async_handle_partial_json = asyncHandlePartialJson;
+function convertToModel(result, outputPydantic, outputJson, agent = null, converterClass) {
+  const model = outputPydantic ?? outputJson;
+  if (!model) {
+    return result;
+  }
+  if (typeof result !== "string") {
+    return outputJson ? dumpStructuredModel(result, model) : result;
+  }
+  if (converterClass) {
+    throw new ConverterError("Use asyncConvertToModel when converterClass fallback is required.");
+  }
+  try {
+    return validateModel(JSON.stringify(JSON.parse(result)), model, Boolean(outputJson));
+  } catch {
+    return handlePartialJson(result, model, Boolean(outputJson), agent, converterClass);
+  }
+}
+var convert_to_model = convertToModel;
+function convertWithInstructions(result, model, isJsonOutput, agent, converterClass = Converter) {
+  if (!agent) {
+    throw new TypeError("Agent must be provided if converter_cls is not specified.");
+  }
+  if (converterClass !== Converter) {
+    throw new ConverterError("Use asyncConvertToModel when converterClass fallback is required.");
+  }
+  const llm = agent.functionCallingLlm ?? agent.function_calling_llm ?? agent.llm;
+  if (!llm) {
+    throw new Error("Agent must have a valid LLM instance for conversion");
+  }
+  const response = llm.call(
+    [
+      { role: "system", content: getConversionInstructions(model, llm) },
+      { role: "user", content: result }
+    ],
+    { responseModel: model }
+  );
+  if (isPromiseLike(response)) {
+    throw new ConverterError("Use asyncConvertToModel when the LLM conversion fallback returns a Promise.");
+  }
+  if (isJsonOutput) {
+    const converted = typeof response === "string" ? response : JSON.stringify(response);
+    try {
+      return validateModel(converted, model, true);
+    } catch {
+      return result;
+    }
+  }
+  try {
+    return coerceResponseToModel(response, model);
+  } catch {
+    return result;
+  }
+}
+var convert_with_instructions = convertWithInstructions;
+var convertWithInstructionsSync = convertWithInstructions;
+var convert_with_instructions_sync = convertWithInstructions;
+async function asyncConvertWithInstructions(result, model, isJsonOutput, agent, converterClass = Converter) {
+  if (!agent) {
+    throw new TypeError("Agent must be provided if converter_cls is not specified.");
+  }
+  const llm = agent.functionCallingLlm ?? agent.function_calling_llm ?? agent.llm;
+  if (!llm) {
+    throw new Error("Agent must have a valid LLM instance for conversion");
+  }
+  const converter = new converterClass({
+    agent,
+    llm,
+    text: result,
+    model,
+    instructions: getConversionInstructions(model, llm)
+  });
+  const converted = isJsonOutput ? await converter.toJson() : await converter.toPydantic();
+  if (converted instanceof ConverterError) {
+    return result;
+  }
+  if (isJsonOutput && typeof converted === "string") {
+    return validateModel(converted, model, true);
+  }
+  return converted;
+}
+var async_convert_with_instructions = asyncConvertWithInstructions;
+function createConverter(first, converterClass, ...args) {
+  if (isConverterOptions(first) && converterClass === void 0 && args.length === 0) {
+    const options = first;
+    return new Converter(options);
+  }
+  let converter;
+  if (first && !converterClass) {
+    const agent = first;
+    const factory = typeof agent.getOutputConverter === "function" ? agent.getOutputConverter : agent.get_output_converter;
+    if (!factory) {
+      throw new Error("Agent does not have a 'get_output_converter' method");
+    }
+    converter = factory(...args);
+  } else if (converterClass) {
+    converter = new converterClass(...args);
+  } else {
+    throw new Error("Either agent or converter_cls must be provided");
+  }
+  if (!converter) {
+    throw new Error("No output converter found or set.");
+  }
+  return converter;
+}
+var create_converter = createConverter;
+async function asyncConvertToModel(result, outputPydantic, outputJson, agent = null, converterClass) {
+  const model = outputPydantic ?? outputJson;
+  if (!model) {
+    return result;
+  }
+  if (typeof result !== "string") {
+    return outputJson ? dumpStructuredModel(result, model) : result;
+  }
+  try {
+    return validateModel(JSON.stringify(JSON.parse(result)), model, Boolean(outputJson));
+  } catch {
+    if (converterClass) {
+      return await asyncConvertWithInstructions(result, model, Boolean(outputJson), agent, converterClass);
+    }
+    return await asyncHandlePartialJson(result, model, Boolean(outputJson), agent, converterClass);
+  }
+}
+var async_convert_to_model = asyncConvertToModel;
+function getConversionInstructions(model, _llm) {
+  void _llm;
+  return `Convert the following text into the requested JSON schema:
+${JSON.stringify(describeModel(model), null, 2)}`;
+}
+var get_conversion_instructions = getConversionInstructions;
+function coerceResponseToModel(response, model) {
+  if (typeof response === "string") {
+    try {
+      return validateStructuredModel(parseJsonLenient(response), model);
+    } catch {
+      const partial = handlePartialJson(response, model, false);
+      if (typeof partial === "string") {
+        throw new ConverterError(`Failed to convert partial JSON result into Pydantic: ${partial}`);
+      }
+      return partial;
+    }
+  }
+  return validateStructuredModel(response, model);
+}
+function parseJsonLenient(result) {
+  try {
+    return JSON.parse(result);
+  } catch (error) {
+    try {
+      return JSON.parse(escapeControlCharactersInsideStrings(result));
+    } catch {
+      throw error;
+    }
+  }
+}
+function escapeControlCharactersInsideStrings(result) {
+  let output = "";
+  let inString = false;
+  let escaped = false;
+  for (const char of result) {
+    if (escaped) {
+      output += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      output += char;
+      escaped = inString;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      output += char;
+      continue;
+    }
+    if (inString && char.charCodeAt(0) < 32) {
+      output += escapeJsonControlCharacter(char);
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+function escapeJsonControlCharacter(char) {
+  switch (char) {
+    case "\b":
+      return "\\b";
+    case "\f":
+      return "\\f";
+    case "\n":
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "	":
+      return "\\t";
+    default:
+      return `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`;
+  }
+}
+function supportsFunctionCalling(llm) {
+  if (typeof llm.supportsFunctionCalling === "function") {
+    return llm.supportsFunctionCalling();
+  }
+  if (typeof llm.supports_function_calling === "function") {
+    return llm.supports_function_calling();
+  }
+  return true;
+}
+async function callLlmAsync(llm, messages, options) {
+  if (typeof llm.acall === "function") {
+    return await llm.acall(messages, options);
+  }
+  return await llm.call(messages, options);
+}
+function validateStructuredModel(value, model) {
+  if (typeof model === "function") {
+    return model(value);
+  }
+  if (model.modelValidate) {
+    return model.modelValidate(value);
+  }
+  if (model.model_validate) {
+    return model.model_validate(value);
+  }
+  if (typeof value === "string" && model.modelValidateJson) {
+    return model.modelValidateJson(value);
+  }
+  if (typeof value === "string" && model.model_validate_json) {
+    return model.model_validate_json(value);
+  }
+  return value;
+}
+function dumpStructuredModel(value, model) {
+  if (typeof model !== "function" && model.modelDump) {
+    return model.modelDump(value);
+  }
+  if (typeof model !== "function" && model.model_dump) {
+    return model.model_dump(value);
+  }
+  return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : { value };
+}
+function isPromiseLike(value) {
+  return Boolean(value && typeof value === "object" && "then" in value && typeof value.then === "function");
+}
+function isConverterOptions(value) {
+  return Boolean(
+    value && typeof value === "object" && "llm" in value && "text" in value && "model" in value && "instructions" in value
+  );
+}
+function describeModel(model) {
+  return typeof model === "function" ? { name: model.name || "Model" } : model.schema ?? { name: model.name ?? "Model" };
+}
+
+// src/security.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+var CREW_AI_NAMESPACE = "f47ac10b-58cc-4372-a567-0e02b2c3d479";
+var Fingerprint = class _Fingerprint {
+  uuidValue;
+  createdAtValue;
+  metadata;
+  constructor(options = {}) {
+    this.uuidValue = randomUUID();
+    this.createdAtValue = /* @__PURE__ */ new Date();
+    this.metadata = validateMetadata(options.metadata ?? {});
+  }
+  get uuidStr() {
+    return this.uuidValue;
+  }
+  get uuid_str() {
+    return this.uuidStr;
+  }
+  get createdAt() {
+    return this.createdAtValue;
+  }
+  get created_at() {
+    return this.createdAt;
+  }
+  get uuid() {
+    validateUuid(this.uuidValue);
+    return this.uuidValue;
+  }
+  static generate(seed, metadata) {
+    const fingerprint = new _Fingerprint({ metadata: metadata ?? {} });
+    if (seed !== void 0 && seed !== null) {
+      fingerprint.uuidValue = _Fingerprint.generateUuid(seed);
+    }
+    return fingerprint;
+  }
+  static generateUuid(seed) {
+    if (!seed.trim()) {
+      throw new Error("Seed cannot be empty or whitespace");
+    }
+    return uuidV5(seed, CREW_AI_NAMESPACE);
+  }
+  static _generate_uuid(seed) {
+    return _Fingerprint.generateUuid(seed);
+  }
+  static fromDict(data) {
+    if (!data) {
+      return new _Fingerprint();
+    }
+    const fingerprint = new _Fingerprint({ metadata: data.metadata ?? {} });
+    fingerprint.uuidValue = data.uuidStr ?? data.uuid_str ?? fingerprint.uuidValue;
+    const createdAt = data.createdAt ?? data.created_at;
+    if (createdAt) {
+      fingerprint.createdAtValue = new Date(createdAt);
+    }
+    return fingerprint;
+  }
+  static from_dict(data) {
+    return _Fingerprint.fromDict(data);
+  }
+  toDict() {
+    return {
+      uuid_str: this.uuidStr,
+      created_at: this.createdAt.toISOString(),
+      metadata: this.metadata
+    };
+  }
+  to_dict() {
+    return this.toDict();
+  }
+  equals(other) {
+    return other instanceof _Fingerprint && other.uuidStr === this.uuidStr;
+  }
+  __eq__(other) {
+    return this.equals(other);
+  }
+  __hash__() {
+    return stringHash(this.uuidStr);
+  }
+  toString() {
+    return this.uuidStr;
+  }
+  __str__() {
+    return this.toString();
+  }
+};
+function stringHash(value) {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = Math.imul(31, hash) + value.charCodeAt(index);
+    hash |= 0;
+  }
+  return hash;
+}
+var SecurityConfig = class _SecurityConfig {
+  fingerprint;
+  constructor(options = {}) {
+    this.fingerprint = coerceFingerprint(options.fingerprint);
+  }
+  static validateFingerprint(value) {
+    return coerceFingerprint(value);
+  }
+  static validate_fingerprint(value) {
+    return _SecurityConfig.validateFingerprint(value);
+  }
+  static fromDict(data) {
+    return new _SecurityConfig({ fingerprint: data?.fingerprint ?? null });
+  }
+  static from_dict(data) {
+    return _SecurityConfig.fromDict(data);
+  }
+  cloneWithNewFingerprint() {
+    return new _SecurityConfig({
+      fingerprint: new Fingerprint({ metadata: { ...this.fingerprint.metadata } })
+    });
+  }
+  toDict() {
+    return { fingerprint: this.fingerprint.toDict() };
+  }
+  to_dict() {
+    return this.toDict();
+  }
+};
+function coerceSecurityConfig(value) {
+  if (value instanceof SecurityConfig) {
+    return value;
+  }
+  return new SecurityConfig(value ?? {});
+}
+function coerceFingerprint(value) {
+  if (value === void 0 || value === null) {
+    return new Fingerprint();
+  }
+  if (value instanceof Fingerprint) {
+    return value;
+  }
+  if (typeof value === "string") {
+    if (!value.trim()) {
+      throw new Error("Fingerprint seed cannot be empty");
+    }
+    return Fingerprint.generate(value);
+  }
+  return Fingerprint.fromDict(value);
+}
+function validateMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+    throw new Error("Metadata must be a dictionary");
+  }
+  const record = metadata;
+  for (const [key, value] of Object.entries(record)) {
+    if (typeof key !== "string") {
+      throw new Error(`Metadata keys must be strings, got ${typeof key}`);
+    }
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      for (const [nestedKey, nestedValue] of Object.entries(value)) {
+        if (typeof nestedKey !== "string") {
+          throw new Error(`Nested metadata keys must be strings, got ${typeof nestedKey}`);
+        }
+        if (nestedValue && typeof nestedValue === "object" && !Array.isArray(nestedValue)) {
+          throw new Error("Metadata can only be nested one level deep");
+        }
+      }
+    }
+  }
+  if (JSON.stringify(record).length > 1e4) {
+    throw new Error("Metadata size exceeds maximum allowed (10KB)");
+  }
+  return { ...record };
+}
+var _validate_metadata = validateMetadata;
+function uuidV5(seed, namespace) {
+  const namespaceBytes = uuidToBytes(namespace);
+  const seedBytes = Buffer.from(seed, "utf8");
+  const hash = createHash2("sha1").update(namespaceBytes).update(seedBytes).digest();
+  const bytes = Buffer.from(hash.subarray(0, 16));
+  bytes[6] = (bytes[6] ?? 0) & 15 | 80;
+  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+  return bytesToUuid(bytes);
+}
+function uuidToBytes(uuid) {
+  validateUuid(uuid);
+  return Buffer.from(uuid.replaceAll("-", ""), "hex");
+}
+function bytesToUuid(bytes) {
+  const hex = bytes.toString("hex");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20, 32)
+  ].join("-");
+}
+function validateUuid(uuid) {
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(uuid)) {
+    throw new Error(`Invalid UUID: ${uuid}`);
+  }
+}
+
+// src/tools.ts
+var OPENAI_BIGGER_MODELS = Object.freeze([
+  "gpt-4",
+  "gpt-4o",
+  "gpt-4.1"
+]);
+var EnvVar = class {
+  name;
+  description;
+  required;
+  default;
+  constructor(options) {
+    this.name = options.name;
+    this.description = options.description;
+    this.required = options.required ?? true;
+    this.default = options.default ?? null;
+  }
+};
+var ToolCalling = class ToolCalling2 {
+  toolName;
+  tool_name;
+  arguments;
+  constructor(options) {
+    const toolName = options.toolName ?? options.tool_name;
+    if (!toolName) {
+      throw new Error("ToolCalling requires a toolName or tool_name.");
+    }
+    this.toolName = toolName;
+    this.tool_name = toolName;
+    this.arguments = options.arguments ?? null;
+  }
+};
+var InstructorToolCalling = ToolCalling;
+var _ArgsSchemaPlaceholder = class {
+  kind = "_ArgsSchemaPlaceholder";
+};
+function _default_cache_function(_args = null, _result = null) {
+  void _args;
+  void _result;
+  return true;
+}
+function _is_async_callable(func) {
+  return typeof func === "function" && func.constructor.name === "AsyncFunction";
+}
+function _is_awaitable(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
+}
+function _serialize_schema(schema) {
+  return schema ? { ...schema } : null;
+}
+function _deserialize_schema(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (isToolArgsSchema(value)) {
+    return { ...value };
+  }
+  return null;
+}
+var ToolResult = class {
+  result;
+  resultAsAnswer;
+  result_as_answer;
+  constructor(resultOrOptions, resultAsAnswer = false) {
+    if (isToolResultOptions(resultOrOptions)) {
+      this.result = resultOrOptions.result;
+      this.resultAsAnswer = resultOrOptions.resultAsAnswer ?? resultOrOptions.result_as_answer ?? false;
+    } else {
+      this.result = resultOrOptions;
+      this.resultAsAnswer = resultAsAnswer;
+    }
+    this.result_as_answer = this.resultAsAnswer;
+  }
+};
+function build_schema_hint(argsSchema = null) {
+  if (!argsSchema || Object.keys(argsSchema).length === 0) {
+    return "";
+  }
+  const properties = Object.fromEntries(Object.entries(argsSchema).map(([name, spec]) => {
+    const property = Object.fromEntries(Object.entries(spec).filter(([key]) => key !== "required"));
+    return [name, property];
+  }));
+  const required = Object.entries(argsSchema).filter(([, spec]) => spec.required).map(([name]) => name);
+  return `
+Expected arguments: ${jsonDumpsForHint(properties)}
+Required: ${jsonDumpsForHint(required)}`;
+}
+var ToolUsageLimitExceededError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ToolUsageLimitExceededError";
+  }
+};
+var ToolValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ToolValidationError";
+  }
+};
+var InMemoryToolCache = class {
+  cache = /* @__PURE__ */ new Map();
+  read(toolName, input) {
+    const key = toolCacheKey(toolName, input);
+    if (!this.cache.has(key)) {
+      return { hit: false };
+    }
+    return { hit: true, value: this.cache.get(key) };
+  }
+  write(toolName, input, output) {
+    this.cache.set(toolCacheKey(toolName, input), output);
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+var CacheHandler = class {
+  cache = /* @__PURE__ */ new Map();
+  add(tool, input, output) {
+    this.cache.set(toolCacheKey(tool, input), output);
+  }
+  read(tool, input) {
+    return this.cache.has(toolCacheKey(tool, input)) ? this.cache.get(toolCacheKey(tool, input)) : null;
+  }
+  clear() {
+    this.cache.clear();
+  }
+  asToolCache() {
+    return {
+      read: (toolName, input) => {
+        const value = this.read(toolName, input);
+        return value === null ? { hit: false } : { hit: true, value };
+      },
+      write: (toolName, input, output) => {
+        this.add(toolName, input, output);
+      },
+      clear: () => {
+        this.clear();
+      }
+    };
+  }
+};
+var ToolsHandler = class {
+  cache;
+  lastUsedTool;
+  last_used_tool;
+  constructor(options = {}) {
+    this.cache = options.cache ?? null;
+    this.lastUsedTool = options.lastUsedTool ?? options.last_used_tool ?? null;
+    this.last_used_tool = this.lastUsedTool;
+  }
+  onToolUse(calling, output, shouldCache = true) {
+    this.lastUsedTool = calling;
+    this.last_used_tool = calling;
+    if (!this.cache || !shouldCache || sanitizedCallingName(calling) === "hit_tool_cache") {
+      return;
+    }
+    this.cache.add(
+      sanitizedCallingName(calling),
+      stringifyToolCallingArguments(calling.arguments),
+      output
+    );
+  }
+  on_tool_use(calling, output, should_cache = true) {
+    this.onToolUse(calling, output, should_cache);
+  }
+};
+var BaseTool = class _BaseTool {
+  name;
+  description;
+  envVars;
+  argsSchema;
+  descriptionUpdated;
+  resultAsAnswer;
+  maxUsageCount;
+  cacheFunction;
+  cache;
+  currentUsageCount = 0;
+  constructor(options) {
+    const maxUsageCount = options.maxUsageCount ?? options.max_usage_count ?? null;
+    _BaseTool.validateMaxUsageCount(maxUsageCount);
+    this.name = sanitizeToolName(options.name);
+    this.description = options.description;
+    this.envVars = options.envVars ?? options.env_vars ?? [];
+    this.argsSchema = options.argsSchema ?? options.args_schema ?? {};
+    this.descriptionUpdated = options.descriptionUpdated ?? options.description_updated ?? false;
+    this.resultAsAnswer = options.resultAsAnswer ?? options.result_as_answer ?? false;
+    this.maxUsageCount = maxUsageCount;
+    this.currentUsageCount = options.currentUsageCount ?? options.current_usage_count ?? 0;
+    this.cacheFunction = options.cacheFunction ?? options.cache_function ?? _default_cache_function;
+    this.cache = options.cache === false ? null : options.cache ?? new InMemoryToolCache();
+  }
+  static validateMaxUsageCount(value) {
+    if (value !== null && value <= 0) {
+      throw new Error("max_usage_count must be a positive integer");
+    }
+    return value;
+  }
+  static validate_max_usage_count(value) {
+    return this.validateMaxUsageCount(value);
+  }
+  static defaultArgsSchema(value) {
+    return _deserialize_schema(value) ?? {};
+  }
+  static _default_args_schema(value) {
+    return this.defaultArgsSchema(value);
+  }
+  static fromLangchain(tool) {
+    if (typeof tool.func !== "function") {
+      throw new Error("The provided tool must have a callable 'func' attribute.");
+    }
+    const func = tool.func;
+    return new StructuredTool({
+      name: tool.name ?? "Unnamed Tool",
+      description: tool.description ?? "",
+      argsSchema: tool.argsSchema ?? tool.args_schema ?? {},
+      func
+    });
+  }
+  static from_langchain(tool) {
+    return this.fromLangchain(tool);
+  }
+  get toolType() {
+    return this.constructor.name;
+  }
+  get tool_type() {
+    return this.toolType;
+  }
+  modelPostInit(_context) {
+    void _context;
+  }
+  model_post_init(_context) {
+    this.modelPostInit(_context);
+  }
+  setArgsSchema() {
+    return this.argsSchema;
+  }
+  _set_args_schema() {
+    return this.setArgsSchema();
+  }
+  generateDescription() {
+    return this.renderDescription();
+  }
+  _generate_description() {
+    return this.generateDescription();
+  }
+  serializeArgsSchema(schema = this.argsSchema) {
+    return schema === null ? null : { ...schema };
+  }
+  _serialize_args_schema(schema = this.argsSchema) {
+    return this.serializeArgsSchema(schema);
+  }
+  _claim_usage() {
+    return this.claimUsage();
+  }
+  validateKwargs(kwargs) {
+    return validateArgs(this.name, this.argsSchema, kwargs);
+  }
+  _validate_kwargs(kwargs) {
+    return this.validateKwargs(kwargs);
+  }
+  get env_vars() {
+    return this.envVars;
+  }
+  get args_schema() {
+    return this.argsSchema;
+  }
+  get args() {
+    return this.argsSchema;
+  }
+  get description_updated() {
+    return this.descriptionUpdated;
+  }
+  get result_as_answer() {
+    return this.resultAsAnswer;
+  }
+  get max_usage_count() {
+    return this.maxUsageCount;
+  }
+  get current_usage_count() {
+    return this.currentUsageCount;
+  }
+  set current_usage_count(value) {
+    this.currentUsageCount = value;
+  }
+  get cache_function() {
+    return this.cacheFunction;
+  }
+  run(input, hookContext = {}) {
+    let args;
+    try {
+      args = this.parseArgs(input);
+    } catch (error) {
+      crewaiEventBus.emit(this, new ToolValidateInputErrorEvent({
+        toolName: this.name,
+        toolArgs: rawToolArgs(input),
+        toolClass: this.constructor.name,
+        error
+      }));
+      throw error;
+    }
+    if (getBeforeToolCallHooks().length > 0 || getAfterToolCallHooks().length > 0) {
+      return this.runWithHooks(args, hookContext);
+    }
+    const startedAt = /* @__PURE__ */ new Date();
+    crewaiEventBus.emit(this, new ToolUsageStartedEvent({
+      toolName: this.name,
+      toolArgs: args,
+      toolClass: this.constructor.name,
+      ...toolEventContext(hookContext)
+    }));
+    const cacheInput = stableStringify(args);
+    const cached = this.cache?.read(this.name, cacheInput);
+    if (cached?.hit) {
+      this.emitToolFinished(args, startedAt, cached.value, hookContext);
+      return cached.value;
+    }
+    try {
+      const usageLimitError = this.claimUsage();
+      if (usageLimitError) {
+        this.emitToolFinished(args, startedAt, usageLimitError, hookContext);
+        return usageLimitError;
+      }
+      const result = this._run(args);
+      if (isPromiseLike2(result)) {
+        return result.then((output) => {
+          this.writeCache(args, cacheInput, output);
+          this.emitToolFinished(args, startedAt, output, hookContext);
+          return output;
+        }).catch((error) => {
+          this.emitToolError(args, error, hookContext);
+          throw error;
+        });
+      }
+      this.writeCache(args, cacheInput, result);
+      this.emitToolFinished(args, startedAt, result, hookContext);
+      return result;
+    } catch (error) {
+      this.emitToolError(args, error, hookContext);
+      throw error;
+    }
+  }
+  async runWithHooks(args, hookContext) {
+    await runBeforeToolCallHooks(new ToolCallHookContext({
+      toolName: this.name,
+      toolInput: args,
+      tool: this,
+      agent: hookContext.agent,
+      task: hookContext.task,
+      crew: hookContext.crew
+    }));
+    const startedAt = /* @__PURE__ */ new Date();
+    crewaiEventBus.emit(this, new ToolUsageStartedEvent({
+      toolName: this.name,
+      toolArgs: args,
+      toolClass: this.constructor.name,
+      ...toolEventContext(hookContext)
+    }));
+    const cacheInput = stableStringify(args);
+    const cached = this.cache?.read(this.name, cacheInput);
+    if (cached?.hit) {
+      this.emitToolFinished(args, startedAt, cached.value, hookContext);
+      return cached.value;
+    }
+    try {
+      const usageLimitError = this.claimUsage();
+      if (usageLimitError) {
+        this.emitToolFinished(args, startedAt, usageLimitError, hookContext);
+        return usageLimitError;
+      }
+      const rawResult = await this._run(args);
+      const result = await runAfterToolCallHooks(new ToolCallHookContext({
+        toolName: this.name,
+        toolInput: args,
+        tool: this,
+        agent: hookContext.agent,
+        task: hookContext.task,
+        crew: hookContext.crew,
+        toolResult: rawResult
+      }));
+      this.writeCache(args, cacheInput, result);
+      this.emitToolFinished(args, startedAt, result, hookContext);
+      return result;
+    } catch (error) {
+      this.emitToolError(args, error, hookContext);
+      throw error;
+    }
+  }
+  async arun(input) {
+    let args;
+    try {
+      args = this.parseArgs(input);
+    } catch (error) {
+      crewaiEventBus.emit(this, new ToolValidateInputErrorEvent({
+        toolName: this.name,
+        toolArgs: rawToolArgs(input),
+        toolClass: this.constructor.name,
+        error
+      }));
+      throw error;
+    }
+    const startedAt = /* @__PURE__ */ new Date();
+    crewaiEventBus.emit(this, new ToolUsageStartedEvent({
+      toolName: this.name,
+      toolArgs: args,
+      toolClass: this.constructor.name
+    }));
+    const cacheInput = stableStringify(args);
+    const cached = this.cache?.read(this.name, cacheInput);
+    if (cached?.hit) {
+      this.emitToolFinished(args, startedAt, cached.value);
+      return cached.value;
+    }
+    try {
+      const usageLimitError = this.claimUsage();
+      if (usageLimitError) {
+        this.emitToolFinished(args, startedAt, usageLimitError);
+        return usageLimitError;
+      }
+      const result = await this._arun(args);
+      this.writeCache(args, cacheInput, result);
+      this.emitToolFinished(args, startedAt, result);
+      return result;
+    } catch (error) {
+      this.emitToolError(args, error);
+      throw error;
+    }
+  }
+  invoke(input, _config) {
+    void _config;
+    return this.run(input);
+  }
+  async ainvoke(input, _config) {
+    void _config;
+    return await this.arun(input);
+  }
+  hasReachedMaxUsageCount() {
+    return this.maxUsageCount !== null && this.currentUsageCount >= this.maxUsageCount;
+  }
+  has_reached_max_usage_count() {
+    return this.hasReachedMaxUsageCount();
+  }
+  resetUsageCount() {
+    this.currentUsageCount = 0;
+  }
+  reset_usage_count() {
+    this.resetUsageCount();
+  }
+  clearCache() {
+    this.cache?.clear?.();
+  }
+  clear_cache() {
+    this.clearCache();
+  }
+  toStructuredTool() {
+    return this.withCache(this.cache ?? false);
+  }
+  to_structured_tool() {
+    return this.toStructuredTool();
+  }
+  toLangChain() {
+    return this.toStructuredTool();
+  }
+  to_langchain() {
+    return this.toLangChain();
+  }
+  withCache(cache) {
+    return new StructuredTool({
+      name: this.name,
+      description: this.description,
+      argsSchema: this.argsSchema,
+      resultAsAnswer: this.resultAsAnswer,
+      maxUsageCount: this.maxUsageCount,
+      currentUsageCount: this.currentUsageCount,
+      cacheFunction: this.cacheFunction,
+      cache,
+      func: (args) => this._run(args),
+      originalTool: this
+    });
+  }
+  renderDescription() {
+    return [
+      `Tool Name: ${this.name}`,
+      `Tool Arguments: ${JSON.stringify(this.argsSchema)}`,
+      `Tool Description: ${this.description}`
+    ].join("\n");
+  }
+  _arun(args) {
+    void args;
+    return Promise.reject(new Error(`${this.constructor.name} does not implement _arun. Override _arun for async support or use run() for sync execution.`));
+  }
+  parseArgs(input) {
+    const raw = normalizeToolInput(input);
+    return validateArgs(this.name, this.argsSchema, raw);
+  }
+  claimUsage() {
+    if (this.maxUsageCount !== null && this.currentUsageCount >= this.maxUsageCount) {
+      return `Tool '${this.name}' has reached its usage limit of ${String(this.maxUsageCount)} times and cannot be used anymore.`;
+    }
+    this.currentUsageCount += 1;
+    this.onUsageClaimed();
+    return null;
+  }
+  onUsageClaimed() {
+  }
+  writeCache(args, cacheInput, output) {
+    if (this.cache && this.cacheFunction(args, output)) {
+      this.cache.write(this.name, cacheInput, output);
+    }
+  }
+  emitToolFinished(args, startedAt, output, hookContext = {}) {
+    crewaiEventBus.emit(this, new ToolUsageFinishedEvent({
+      toolName: this.name,
+      toolArgs: args,
+      toolClass: this.constructor.name,
+      startedAt,
+      output,
+      ...toolEventContext(hookContext)
+    }));
+  }
+  emitToolError(args, error, hookContext = {}) {
+    crewaiEventBus.emit(this, new ToolUsageErrorEvent({
+      toolName: this.name,
+      toolArgs: args,
+      toolClass: this.constructor.name,
+      error,
+      ...toolEventContext(hookContext)
+    }));
+  }
+};
+function toolEventContext(hookContext) {
+  const context = {};
+  if (hookContext.task !== void 0) {
+    context.from_task = hookContext.task;
+  }
+  if (hookContext.agent !== void 0) {
+    context.from_agent = hookContext.agent;
+    const agentRecord = hookContext.agent && typeof hookContext.agent === "object" ? hookContext.agent : {};
+    if (typeof agentRecord.key === "string") {
+      context.agent_key = agentRecord.key;
+    }
+    if (typeof agentRecord.role === "string") {
+      context.agent_role = agentRecord.role;
+    }
+  }
+  return context;
+}
+function to_langchain(toolOrTools) {
+  if (Array.isArray(toolOrTools)) {
+    return toolOrTools.map((tool) => tool instanceof StructuredTool ? tool : tool.toStructuredTool());
+  }
+  return toolOrTools.toStructuredTool();
+}
+var StructuredTool = class extends BaseTool {
+  func;
+  originalTool;
+  constructor(options) {
+    super(options);
+    this.func = options.func;
+    this.originalTool = options.originalTool ?? options.original_tool ?? null;
+  }
+  static fromFunction(func, optionsOrName = {}, description, returnDirect = false, argsSchema, inferSchema = true) {
+    const options = normalizeFromFunctionOptions(optionsOrName, description, returnDirect, argsSchema, inferSchema);
+    const shouldInferSchema = options.inferSchema ?? options.infer_schema ?? true;
+    if (!shouldInferSchema && !(options.argsSchema ?? options.args_schema)) {
+      throw new Error("Either argsSchema must be provided or inferSchema must be true.");
+    }
+    return createToolFromFunction(func, {
+      ...options,
+      resultAsAnswer: options.returnDirect ?? options.return_direct ?? false
+    });
+  }
+  static from_function(func, optionsOrName = {}, description, returnDirect = false, argsSchema, inferSchema = true) {
+    const options = normalizeFromFunctionOptions(optionsOrName, description, returnDirect, argsSchema, inferSchema);
+    const shouldInferSchema = options.inferSchema ?? options.infer_schema ?? true;
+    if (!shouldInferSchema && !(options.argsSchema ?? options.args_schema)) {
+      throw new Error("Either argsSchema must be provided or inferSchema must be true.");
+    }
+    return createToolFromFunction(func, {
+      ...options,
+      resultAsAnswer: options.returnDirect ?? options.return_direct ?? false
+    });
+  }
+  _run(args) {
+    return this.callStructuredFunction(args);
+  }
+  parseArgs(input) {
+    const rawArgs = normalizeStructuredToolInput(input, this.argsSchema, false);
+    return validateArgs(this.name, this.argsSchema, rawArgs);
+  }
+  invoke(input, _config) {
+    void _config;
+    const parsedArgs = this._parseArgs(input);
+    if (this.hasReachedMaxUsageCount()) {
+      throw new ToolUsageLimitExceededError(
+        `Tool '${sanitizeToolName(this.name)}' has reached its maximum usage limit of ${String(this.maxUsageCount)}. You should not use the ${sanitizeToolName(this.name)} tool again.`
+      );
+    }
+    this._incrementUsageCount();
+    return this.callStructuredFunction(parsedArgs);
+  }
+  async ainvoke(input, _config) {
+    void _config;
+    const parsedArgs = this._parseArgs(input);
+    if (this.hasReachedMaxUsageCount()) {
+      throw new ToolUsageLimitExceededError(
+        `Tool '${sanitizeToolName(this.name)}' has reached its maximum usage limit of ${String(this.maxUsageCount)}. You should not use the ${sanitizeToolName(this.name)} tool again.`
+      );
+    }
+    this._incrementUsageCount();
+    return await this.callStructuredFunction(parsedArgs);
+  }
+  async arun(input) {
+    return await this.run(input);
+  }
+  _validate_func() {
+    this._validate_function_signature();
+    return this;
+  }
+  static _create_schema_from_function(name, func) {
+    void name;
+    const parameterNames = inferFunctionParameterNames(func);
+    return Object.fromEntries(parameterNames.map((parameterName) => [
+      parameterName,
+      { type: "unknown", required: true }
+    ]));
+  }
+  _validate_function_signature() {
+    const parameterNames = inferFunctionParameterNames(this.func);
+    if (parameterNames.length === 1 && parameterNames[0] === "args" && !this.argsSchema.args) {
+      return;
+    }
+    for (const parameterName of parameterNames) {
+      const spec = this.argsSchema[parameterName];
+      if (!spec) {
+        throw new Error(`Required function parameter '${parameterName}' not found in args_schema`);
+      }
+    }
+  }
+  _parseArgs(input) {
+    const rawArgs = normalizeStructuredToolInput(input, this.argsSchema, true);
+    try {
+      return validateArgs(this.name, this.argsSchema, rawArgs);
+    } catch (error) {
+      throw new Error(`Arguments validation failed: ${error instanceof Error ? error.message : String(error)}${build_schema_hint(this.argsSchema)}`, {
+        cause: error
+      });
+    }
+  }
+  _parse_args(input) {
+    return this._parseArgs(input);
+  }
+  _incrementUsageCount() {
+    this.currentUsageCount += 1;
+    this.onUsageClaimed();
+  }
+  _increment_usage_count() {
+    this._incrementUsageCount();
+  }
+  callStructuredFunction(parsedArgs) {
+    const parameterNames = inferFunctionParameterNames(this.func);
+    if (parameterNames.length <= 1) {
+      return this.func(parsedArgs);
+    }
+    const orderedNames = Object.keys(this.argsSchema).length > 0 ? Object.keys(this.argsSchema) : parameterNames;
+    const positional = orderedNames.map((parameterName) => parsedArgs[parameterName]);
+    return this.func(...positional);
+  }
+  __repr__() {
+    return `CrewStructuredTool(name='${sanitizeToolName(this.name)}', description='${this.description}')`;
+  }
+  toString() {
+    return this.__repr__();
+  }
+  onUsageClaimed() {
+    if (this.originalTool) {
+      this.originalTool.current_usage_count = this.currentUsageCount;
+    }
+  }
+};
+var CrewStructuredTool = StructuredTool;
+var AddImageToolSchema = {
+  image_url: { type: "string", required: true, description: "The URL or path of the image to add" },
+  action: { type: "string", required: false, description: "Optional context or question about the image" }
+};
+var AddImageTool = class extends BaseTool {
+  constructor(options = {}) {
+    const addImage = I18N_DEFAULT.tools("add_image");
+    super({
+      name: options.name ?? addImage.name,
+      description: options.description ?? addImage.description,
+      argsSchema: options.argsSchema ?? options.args_schema ?? AddImageToolSchema,
+      ...baseToolPassthroughOptions(options)
+    });
+  }
+  _run(args) {
+    const addImage = I18N_DEFAULT.tools("add_image");
+    const action = typeof args.action === "string" && args.action.trim() ? args.action : addImage.default_action;
+    return {
+      role: "user",
+      content: [
+        { type: "text", text: action },
+        { type: "image_url", image_url: { url: toToolString(args.image_url) } }
+      ]
+    };
+  }
+};
+var ReadFileToolSchema = {
+  file_name: { type: "string", required: true, description: "The name of the input file to read" }
+};
+var ReadFileTool = class extends BaseTool {
+  files = null;
+  constructor(options = {}) {
+    super({
+      name: options.name ?? "read_file",
+      description: options.description ?? "Read content from an input file by name. Returns file content as text for text files, or base64 for binary files.",
+      argsSchema: options.argsSchema ?? options.args_schema ?? ReadFileToolSchema,
+      cache: options.cache ?? false,
+      ...baseToolPassthroughOptions(options)
+    });
+    this.files = options.files ?? null;
+  }
+  setFiles(files) {
+    this.files = files;
+  }
+  set_files(files) {
+    this.setFiles(files);
+  }
+  _run(args) {
+    if (!this.files) {
+      return "No input files available.";
+    }
+    const fileName = toToolString(args.file_name ?? args.fileName);
+    const file = this.files[fileName];
+    if (!file) {
+      return `File '${fileName}' not found. Available files: ${Object.keys(this.files).join(", ")}`;
+    }
+    const content = file.read();
+    const contentType = file.content_type ?? file.contentType ?? "application/octet-stream";
+    if (contentType === "application/pdf") {
+      const bytes = typeof content === "string" ? Buffer.from(content) : Buffer.from(content);
+      return readPDFFileText(bytes, file.filename ?? fileName);
+    }
+    if (contentType.startsWith("text/") || ["application/json", "application/xml", "application/x-yaml"].includes(contentType)) {
+      return typeof content === "string" ? content : Buffer.from(content).toString("utf8");
+    }
+    const encoded = typeof content === "string" ? Buffer.from(content).toString("base64") : Buffer.from(content).toString("base64");
+    return `[Binary file: ${file.filename ?? fileName} (${contentType})]
+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() ?? "";
+      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)]
+Base64: ${encoded}`;
+    }
+    return `Unable to extract text from PDF '${filename}': ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+var BaseAgentTool = class _BaseAgentTool extends BaseTool {
+  agents;
+  constructor(options = {}) {
+    super({
+      name: options.name ?? "agent_tool",
+      description: options.description ?? "Agent tool",
+      argsSchema: options.argsSchema ?? options.args_schema ?? {},
+      ...baseToolPassthroughOptions(options)
+    });
+    this.agents = options.agents ?? [];
+  }
+  sanitizeAgentName(name) {
+    return name ? name.trim().split(/\s+/).join(" ").replaceAll('"', "").toLocaleLowerCase() : "";
+  }
+  sanitize_agent_name(name) {
+    return this.sanitizeAgentName(name);
+  }
+  static _getCoworker(coworker, args = {}) {
+    const raw = coworker ?? args.co_worker ?? args.coworker;
+    if (typeof raw !== "string") {
+      return null;
+    }
+    if (raw.startsWith("[") && raw.endsWith("]")) {
+      return raw.slice(1, -1).split(",")[0]?.trim() ?? "";
+    }
+    return raw;
+  }
+  static _get_coworker(coworker, args = {}) {
+    return this._getCoworker(coworker, args);
+  }
+  _getCoworker(coworker, args = {}) {
+    return _BaseAgentTool._getCoworker(coworker, args);
+  }
+  _get_coworker(coworker, args = {}) {
+    return this._getCoworker(coworker, args);
+  }
+  _execute(agentName, task, context = null) {
+    const sanitizedName = this.sanitizeAgentName(agentName ?? "");
+    const selectedAgent = this.agents.find((agent) => this.sanitizeAgentName(agent.role) === sanitizedName);
+    if (!selectedAgent) {
+      return I18N_DEFAULT.errors("agent_tool_unexisting_coworker").replace("{coworkers}", this.formatCoworkers());
+    }
+    const execute = selectedAgent.executeTask ?? selectedAgent.execute_task;
+    if (!execute) {
+      return I18N_DEFAULT.errors("agent_tool_execution_error").replace("{agent_role}", this.sanitizeAgentName(selectedAgent.role)).replace("{error}", "Selected agent does not expose executeTask.");
+    }
+    try {
+      const result = execute.call(selectedAgent, { description: task, expected_output: I18N_DEFAULT.slice("manager_request"), agent: selectedAgent }, context);
+      return isPromiseLike2(result) ? result.then(stringifyToolOutput) : stringifyToolOutput(result);
+    } catch (error) {
+      return I18N_DEFAULT.errors("agent_tool_execution_error").replace("{agent_role}", this.sanitizeAgentName(selectedAgent.role)).replace("{error}", error instanceof Error ? error.message : stringifyToolOutput(error));
+    }
+  }
+  _run(args) {
+    void args;
+    throw new Error("BaseAgentTool must be subclassed.");
+  }
+  formatCoworkers() {
+    return this.agents.map((agent) => `- ${this.sanitizeAgentName(agent.role)}`).join("\n");
+  }
+};
+var AskQuestionToolSchema = {
+  question: { type: "string", required: true, description: "The question to ask" },
+  context: { type: "string", required: true, description: "The context for the question" },
+  coworker: { type: "string", required: true, description: "The role/name of the coworker to ask" }
+};
+var AskQuestionTool = class extends BaseAgentTool {
+  constructor(options = {}) {
+    super({
+      ...options,
+      name: options.name ?? "Ask question to coworker",
+      description: options.description ?? "Ask question to coworker",
+      argsSchema: options.argsSchema ?? options.args_schema ?? AskQuestionToolSchema
+    });
+  }
+  _run(args) {
+    return this._execute(
+      this._getCoworker(args.coworker, args),
+      toToolString(args.question),
+      typeof args.context === "string" ? args.context : null
+    );
+  }
+};
+var DelegateWorkToolSchema = {
+  task: { type: "string", required: true, description: "The task to delegate" },
+  context: { type: "string", required: true, description: "The context for the task" },
+  coworker: { type: "string", required: true, description: "The role/name of the coworker to delegate to" }
+};
+var DelegateWorkTool = class extends BaseAgentTool {
+  constructor(options = {}) {
+    super({
+      ...options,
+      name: options.name ?? "Delegate work to coworker",
+      description: options.description ?? "Delegate work to coworker",
+      argsSchema: options.argsSchema ?? options.args_schema ?? DelegateWorkToolSchema
+    });
+  }
+  _run(args) {
+    return this._execute(
+      this._getCoworker(args.coworker, args),
+      toToolString(args.task),
+      typeof args.context === "string" ? args.context : null
+    );
+  }
+};
+var AgentTools = class {
+  agents;
+  constructor(agentsOrOptions) {
+    this.agents = "agents" in agentsOrOptions ? agentsOrOptions.agents : agentsOrOptions;
+  }
+  tools() {
+    const coworkers = this.agents.map((agent) => agent.role).join(", ");
+    return [
+      new DelegateWorkTool({
+        agents: this.agents,
+        description: promptLeafToString(I18N_DEFAULT.tools("delegate_work")).replace("{coworkers}", coworkers)
+      }),
+      new AskQuestionTool({
+        agents: this.agents,
+        description: promptLeafToString(I18N_DEFAULT.tools("ask_question")).replace("{coworkers}", coworkers)
+      })
+    ];
+  }
+};
+var CacheTools = class {
+  cacheHandler;
+  cache_handler;
+  constructor(cacheHandler = new CacheHandler()) {
+    this.cacheHandler = cacheHandler;
+    this.cache_handler = cacheHandler;
+  }
+  tool() {
+    return new StructuredTool({
+      name: "Hit Tool Cache",
+      description: "Read cached output for a previous tool call.",
+      argsSchema: {
+        key: { type: "string", required: true }
+      },
+      func: ({ key }) => this.hitCache(String(key)) ?? ""
+    });
+  }
+  hitCache(key) {
+    const match = key.match(/tool:\s*(.*?)\s*\|\s*input:\s*(.*)$/s);
+    if (!match) {
+      return null;
+    }
+    const [, toolPart = "", inputPart = ""] = match;
+    return this.cacheHandler.read(toolPart.trim(), inputPart.trim());
+  }
+  hit_cache(key) {
+    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);
+    this.name = "ToolUsageError";
+  }
+};
+var ToolUsage = class _ToolUsage {
+  runAttempts = 1;
+  maxParsingAttempts = 3;
+  rememberFormatAfterUsages = 3;
+  toolsHandler;
+  tools_handler;
+  tools;
+  task;
+  functionCallingLlm;
+  function_calling_llm;
+  agent;
+  action;
+  fingerprintContext;
+  fingerprint_context;
+  constructor(options = {}) {
+    this.toolsHandler = options.toolsHandler ?? options.tools_handler ?? null;
+    this.tools_handler = this.toolsHandler;
+    this.tools = options.tools ?? [];
+    this.task = options.task;
+    this.functionCallingLlm = options.functionCallingLlm ?? options.function_calling_llm;
+    this.function_calling_llm = this.functionCallingLlm;
+    this.agent = options.agent;
+    this.action = options.action ?? null;
+    this.fingerprintContext = options.fingerprintContext ?? options.fingerprint_context ?? {};
+    this.fingerprint_context = this.fingerprintContext;
+  }
+  get run_attempts() {
+    return this.runAttempts;
+  }
+  get _run_attempts() {
+    return this.runAttempts;
+  }
+  get _max_parsing_attempts() {
+    return this.maxParsingAttempts;
+  }
+  get _remember_format_after_usages() {
+    return this.rememberFormatAfterUsages;
+  }
+  parseToolCalling(toolString) {
+    const calling = normalizeToolCalling(toolString);
+    return calling ?? new ToolUsageError("Could not parse tool calling.");
+  }
+  parse_tool_calling(toolString) {
+    return this.parseToolCalling(toolString);
+  }
+  async use(calling, toolString = "") {
+    if (calling instanceof ToolUsageError) {
+      return calling.message;
+    }
+    const action = this.action ?? new AgentAction({
+      thought: "",
+      text: toolString,
+      tool: calling.toolName,
+      toolInput: JSON.stringify(calling.arguments ?? {})
+    });
+    const result = await aexecuteToolAndCheckFinality(action, this.tools, {
+      toolsHandler: this.toolsHandler,
+      task: this.task,
+      agent: this.agent,
+      functionCallingLlm: this.functionCallingLlm,
+      fingerprintContext: this.fingerprintContext
+    });
+    return stringifyToolOutput(result.result);
+  }
+  async ause(calling, toolString = "") {
+    return await this.use(calling, toolString);
+  }
+  async _ause(toolString, tool, calling) {
+    if (this._check_tool_repeated_usage(calling)) {
+      return this._format_result(I18N_DEFAULT.errors("task_repeated_usage"));
+    }
+    const startedAt = Date.now() / 1e3;
+    try {
+      const usageLimitError = _ToolUsage._check_usage_limit(tool, sanitizeToolName(tool.name));
+      if (usageLimitError) {
+        throw new ToolUsageLimitExceededError(usageLimitError);
+      }
+      const input = calling.arguments ?? {};
+      const result = await tool.run(input);
+      this.onToolUseFinished(tool, calling, false, startedAt, result);
+      this.toolsHandler?.onToolUse(calling, stringifyToolOutput(result), true);
+      return this._format_result(result);
+    } catch (error) {
+      this.onToolError(tool, calling, error);
+      return stringifyToolError(error);
+    }
+  }
+  _format_result(result) {
+    const taskRecord = getRecord(this.task);
+    if (taskRecord) {
+      const usedTools = typeof taskRecord.used_tools === "number" ? taskRecord.used_tools : 0;
+      taskRecord.used_tools = usedTools + 1;
+    }
+    const output = stringifyToolOutput(result);
+    return this._should_remember_format() ? this._remember_format(output) : output;
+  }
+  _should_remember_format() {
+    const usedTools = getNumberProperty(this.task, "used_tools");
+    return usedTools !== null && usedTools % this.rememberFormatAfterUsages === 0;
+  }
+  _remember_format(result) {
+    const toolsSlice = I18N_DEFAULT.slice("tools").replaceAll("{tools}", renderToolsDescription(this.tools)).replaceAll("{tool_names}", this.tools.map((tool) => sanitizeToolName(tool.name)).join(", "));
+    return `${stringifyToolOutput(result)}
+
+${toolsSlice}`;
+  }
+  _check_tool_repeated_usage(calling) {
+    const lastToolUsage = this.toolsHandler?.lastUsedTool;
+    if (!lastToolUsage) {
+      return false;
+    }
+    return sanitizedCallingName(calling) === sanitizedCallingName(lastToolUsage) && JSON.stringify(calling.arguments ?? {}) === JSON.stringify(lastToolUsage.arguments ?? {});
+  }
+  static _check_usage_limit(tool, toolName) {
+    const record = getRecord(tool);
+    const maxUsageCount = record?.max_usage_count ?? record?.maxUsageCount;
+    const currentUsageCount = record?.current_usage_count ?? record?.currentUsageCount;
+    if (typeof maxUsageCount === "number" && typeof currentUsageCount === "number" && currentUsageCount >= maxUsageCount) {
+      return `Tool '${toolName}' has reached its usage limit of ${String(maxUsageCount)} times and cannot be used anymore.`;
+    }
+    return null;
+  }
+  _check_usage_limit(tool, toolName) {
+    return _ToolUsage._check_usage_limit(tool, toolName);
+  }
+  _select_tool(toolName) {
+    const sanitizedInput = sanitizeToolName(toolName);
+    const orderedTools = [...this.tools].sort((left, right) => toolNameSimilarity(right.name, sanitizedInput) - toolNameSimilarity(left.name, sanitizedInput));
+    for (const tool of orderedTools) {
+      const sanitizedTool = sanitizeToolName(tool.name);
+      if (sanitizedTool === sanitizedInput || toolNameSimilarity(tool.name, sanitizedInput) > 0.85) {
+        return tool;
+      }
+    }
+    incrementTaskToolErrors(this.task);
+    const error = toolName ? `Action '${toolName}' don't exist, these are the only available Actions:
+${renderToolsDescription(this.tools)}` : `I forgot the Action name, these are the only available Actions: ${renderToolsDescription(this.tools)}`;
+    crewaiEventBus.emit(this, new ToolSelectionErrorEvent({
+      toolName,
+      toolArgs: {},
+      toolClass: renderToolsDescription(this.tools),
+      error,
+      ...this.toolUsageErrorEventContext(toolName, {})
+    }));
+    throw new Error(error);
+  }
+  _render() {
+    return this.tools.map((tool) => tool.description ?? "").join("\n--\n");
+  }
+  async _function_calling(toolString) {
+    if (!isLLMClient(this.functionCallingLlm)) {
+      throw new ToolUsageError("Function calling LLM is not available.");
+    }
+    const converter = new Converter({
+      text: `Only tools available:
+###
+${this._render()}
+
+Return a valid schema for the tool, the tool name must be exactly equal one of the options, use this text to inform the valid output schema:
+
+### TEXT 
+${toolString}`,
+      llm: this.functionCallingLlm,
+      model: coerceToolCallingModel,
+      instructions: [
+        "The schema should have the following structure, only two keys:",
+        "- tool_name: str",
+        "- arguments: dict (always a dictionary, with all arguments being passed)",
+        "",
+        "Example:",
+        '{"tool_name":"tool name","arguments":{"arg_name1":"value","arg_name2":2}}'
+      ].join("\n"),
+      maxAttempts: 1
+    });
+    return await converter.toPydantic();
+  }
+  _original_tool_calling(_toolString, raiseError = false) {
+    const action = this.action;
+    if (!action) {
+      return new ToolUsageError(I18N_DEFAULT.errors("tool_arguments_error"));
+    }
+    try {
+      const tool = this._select_tool(action.tool);
+      const arguments_ = this._validate_tool_input(action.toolInput);
+      return new ToolCalling({
+        toolName: sanitizeToolName(tool.name),
+        arguments: arguments_
+      });
+    } catch (error) {
+      if (raiseError) {
+        throw error;
+      }
+      return new ToolUsageError(I18N_DEFAULT.errors("tool_arguments_error"));
+    }
+  }
+  async _tool_calling(toolString) {
+    try {
+      try {
+        return this._original_tool_calling(toolString, true);
+      } catch {
+        if (this.functionCallingLlm) {
+          return await this._function_calling(toolString);
+        }
+        return this._original_tool_calling(toolString);
+      }
+    } catch (error) {
+      this.runAttempts += 1;
+      if (this.runAttempts > this.maxParsingAttempts) {
+        incrementTaskToolErrors(this.task);
+        return new ToolUsageError(
+          `${I18N_DEFAULT.errors("tool_usage_error").replace("{error}", error instanceof Error ? error.message : String(error))}
+Moving on then. ${I18N_DEFAULT.slice("format").replaceAll("{tool_names}", this.tools.map((tool) => sanitizeToolName(tool.name)).join(", "))}`
+        );
+      }
+      return await this._tool_calling(toolString);
+    }
+  }
+  _validate_tool_input(toolInput) {
+    if (toolInput === null || toolInput === void 0) {
+      return {};
+    }
+    if (typeof toolInput !== "string" || toolInput.trim().length === 0) {
+      const error2 = "Tool input must be a valid dictionary in JSON or Python literal format";
+      this._emit_validate_input_error(error2);
+      throw new Error(error2);
+    }
+    const parsed = parseToolInputDictionary(toolInput);
+    if (parsed) {
+      return parsed;
+    }
+    const error = "Tool input must be a valid dictionary in JSON or Python literal format";
+    this._emit_validate_input_error(error);
+    throw new Error(error);
+  }
+  _emit_validate_input_error(finalError) {
+    crewaiEventBus.emit(this, new ToolValidateInputErrorEvent({
+      toolName: this.action?.tool ?? "",
+      toolArgs: this.action?.toolInput ?? "",
+      toolClass: this.constructor.name,
+      error: finalError,
+      ...this.toolUsageErrorEventContext(this.action?.tool ?? "", this.action?.toolInput ?? "")
+    }));
+  }
+  _prepare_event_data(tool, toolCalling) {
+    return this.prepareEventData(tool, toolCalling);
+  }
+  _build_fingerprint_config() {
+    const securityContext = {};
+    const agentFingerprint = fingerprintToRecord(getRecord(getRecord(this.agent)?.security_config)?.fingerprint);
+    if (agentFingerprint) {
+      securityContext.agent_fingerprint = agentFingerprint;
+    }
+    const taskFingerprint = fingerprintToRecord(getRecord(getRecord(this.task)?.security_config)?.fingerprint);
+    if (taskFingerprint) {
+      securityContext.task_fingerprint = taskFingerprint;
+    }
+    return Object.keys(securityContext).length > 0 ? { security_context: securityContext } : {};
+  }
+  onToolError(tool, toolCalling, error) {
+    const eventData = this.prepareEventData(tool, toolCalling);
+    crewaiEventBus.emit(this, new ToolUsageErrorEvent({
+      ...eventData,
+      task_id: getStringProperty(this.task, "id"),
+      task_name: getTaskDisplayName(this.task),
+      error
+    }));
+  }
+  on_tool_error(tool, toolCalling, error) {
+    this.onToolError(tool, toolCalling, error);
+  }
+  onToolUseFinished(tool, toolCalling, fromCache, startedAt, result) {
+    const finishedAt = Date.now() / 1e3;
+    crewaiEventBus.emit(this, new ToolUsageFinishedEvent({
+      ...this.prepareEventData(tool, toolCalling),
+      started_at: new Date(startedAt * 1e3),
+      finished_at: new Date(finishedAt * 1e3),
+      from_cache: fromCache,
+      output: result,
+      ...this.task ? {
+        task_id: getStringProperty(this.task, "id"),
+        task_name: getTaskDisplayName(this.task)
+      } : {}
+    }));
+  }
+  on_tool_use_finished(tool, toolCalling, fromCache, startedAt, result) {
+    this.onToolUseFinished(tool, toolCalling, fromCache, startedAt, result);
+  }
+  prepareEventData(tool, toolCalling) {
+    return {
+      run_attempts: this.run_attempts,
+      delegations: getNumberProperty(this.task, "delegations") ?? 0,
+      tool_name: sanitizeToolName(getStringProperty(tool, "name") ?? toolCalling.toolName ?? toolCalling.tool_name ?? ""),
+      tool_args: toolCalling.arguments ?? {},
+      tool_class: getConstructorName(tool),
+      agent_key: getStringProperty(this.agent, "key") ?? "unknown",
+      agent_role: getStringProperty(this.agent, "_original_role") ?? getStringProperty(this.agent, "role") ?? "unknown",
+      ...this.fingerprintContext
+    };
+  }
+  toolUsageErrorEventContext(toolName, toolArgs) {
+    return {
+      agent_key: getStringProperty(this.agent, "key") ?? "unknown",
+      agent_role: getStringProperty(this.agent, "_original_role") ?? getStringProperty(this.agent, "role") ?? "unknown",
+      tool_name: toolName,
+      tool_args: toolArgs,
+      ...this.fingerprintContext
+    };
+  }
+};
+function createTool(options) {
+  return new StructuredTool(options);
+}
+function functionTool(first, options = {}) {
+  if (typeof first === "function") {
+    return createToolFromFunction(first, {});
+  }
+  const normalizedOptions = typeof first === "string" ? { ...options, name: first } : first;
+  return (func) => createToolFromFunction(func, normalizedOptions);
+}
+var create_tool = createTool;
+var createFunctionTool = functionTool;
+var create_function_tool = functionTool;
+function _make_tool(func) {
+  return createToolFromFunction(func, {});
+}
+function _make_with_name(name, options = {}) {
+  return (func) => createToolFromFunction(func, { ...options, name });
+}
+function _resolve_tool_dict(value) {
+  const name = typeof value.name === "string" ? value.name : "tool";
+  const description = typeof value.description === "string" ? value.description : "";
+  const maxUsageCount = value.maxUsageCount ?? value.max_usage_count;
+  const currentUsageCount = value.currentUsageCount ?? value.current_usage_count;
+  return new StructuredTool({
+    name,
+    description,
+    argsSchema: _deserialize_schema(value.argsSchema ?? value.args_schema) ?? {},
+    resultAsAnswer: Boolean(value.resultAsAnswer ?? value.result_as_answer),
+    maxUsageCount: typeof maxUsageCount === "number" ? maxUsageCount : null,
+    currentUsageCount: typeof currentUsageCount === "number" ? currentUsageCount : 0,
+    cacheFunction: typeof value.cacheFunction === "function" ? value.cacheFunction : typeof value.cache_function === "function" ? value.cache_function : _default_cache_function,
+    func: typeof value.func === "function" ? value.func : (args) => args
+  });
+}
+function createToolFromFunction(func, options) {
+  const inferredName = options.name ?? func.name;
+  if (!inferredName) {
+    throw new Error("Tool function must have a name or explicit tool name.");
+  }
+  const parameterNames = inferFunctionParameterNames(func);
+  const argsSchema = options.argsSchema ?? options.args_schema ?? inferFunctionArgsSchema(func);
+  return new StructuredTool({
+    name: inferredName,
+    description: options.description ?? inferFunctionDescription(func, inferredName),
+    argsSchema,
+    envVars: options.envVars ?? options.env_vars ?? [],
+    resultAsAnswer: options.resultAsAnswer ?? options.result_as_answer ?? false,
+    maxUsageCount: options.maxUsageCount ?? options.max_usage_count ?? null,
+    ...options.cacheFunction === void 0 ? {} : { cacheFunction: options.cacheFunction },
+    ...options.cache === void 0 ? {} : { cache: options.cache },
+    func: (args) => func(...parameterNames.map((parameterName) => args[parameterName]))
+  });
+}
+function normalizeFromFunctionOptions(optionsOrName, description, returnDirect, argsSchema, inferSchema) {
+  if (typeof optionsOrName === "string" || optionsOrName === null) {
+    return {
+      ...optionsOrName === null ? {} : { name: optionsOrName },
+      ...description === void 0 || description === null ? {} : { description },
+      returnDirect,
+      ...argsSchema === void 0 || argsSchema === null ? {} : { argsSchema },
+      inferSchema
+    };
+  }
+  return optionsOrName;
+}
+function isToolCalling(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof (record.toolName ?? record.tool_name) === "string";
+}
+function normalizeToolCalling(value) {
+  if (typeof value === "string") {
+    try {
+      return normalizeToolCalling(JSON.parse(value));
+    } catch {
+      try {
+        const parsed = parseAgentOutput(value);
+        if (!(parsed instanceof AgentAction)) {
+          return null;
+        }
+        return {
+          toolName: parsed.tool,
+          arguments: normalizeToolInput(parsed.toolInput)
+        };
+      } catch (error) {
+        if (error instanceof OutputParserError) {
+          return null;
+        }
+        throw error;
+      }
+    }
+  }
+  if (!isToolCalling(value)) {
+    return null;
+  }
+  const record = value;
+  const args = record.arguments;
+  return {
+    toolName: String(record.toolName ?? record.tool_name),
+    arguments: args && typeof args === "object" && !Array.isArray(args) ? args : null
+  };
+}
+function coerceToolCallingModel(value) {
+  const normalized = normalizeToolCalling(value);
+  if (!normalized) {
+    throw new ToolUsageError("Failed to parse tool calling");
+  }
+  return new ToolCalling(normalized);
+}
+function isLLMClient(value) {
+  return Boolean(value && typeof value === "object" && typeof value.call === "function");
+}
+async function aexecuteToolAndCheckFinality(agentAction, tools, options = {}) {
+  void options.functionCallingLlm;
+  void options.function_calling_llm;
+  const agentKey = options.agentKey ?? options.agent_key ?? null;
+  const agentRole = options.agentRole ?? options.agent_role ?? null;
+  if (agentKey && agentRole && options.agent) {
+    setAgentFingerprintFromContext(options.agent, options.fingerprintContext ?? options.fingerprint_context ?? {});
+  }
+  const toolNameToToolMap = new Map(tools.map((tool2) => [sanitizeToolName(tool2.name), tool2]));
+  const toolCalling = normalizeToolCalling(agentAction.text) ?? {
+    toolName: agentAction.tool,
+    arguments: normalizeToolInput(agentAction.toolInput)
+  };
+  const sanitizedToolName = sanitizeToolName(toolCalling.toolName);
+  const tool = toolNameToToolMap.get(sanitizedToolName);
+  if (!tool) {
+    return new ToolResult({
+      result: I18N_DEFAULT.errors("wrong_tool_name").replaceAll("{tool}", sanitizedToolName).replaceAll("{tools}", [...toolNameToToolMap.keys()].join(", ")),
+      resultAsAnswer: false
+    });
+  }
+  const toolInput = toolCalling.arguments ?? {};
+  const output = tool instanceof BaseTool ? await tool.run(toolInput, { agent: options.agent, task: options.task, crew: options.crew }) : await runPlainToolWithHooks(tool, sanitizedToolName, toolInput, options);
+  const result = new ToolResult({
+    result: output,
+    resultAsAnswer: tool.resultAsAnswer ?? false
+  });
+  const toolsHandler = options.toolsHandler ?? options.tools_handler ?? null;
+  toolsHandler?.onToolUse({
+    toolName: sanitizedToolName,
+    tool_name: sanitizedToolName,
+    arguments: toolInput
+  }, stringifyToolOutput(output), true);
+  return result;
+}
+var aexecute_tool_and_check_finality = aexecuteToolAndCheckFinality;
+function executeToolAndCheckFinality(agentAction, tools, options = {}) {
+  return aexecuteToolAndCheckFinality(agentAction, tools, options);
+}
+var execute_tool_and_check_finality = executeToolAndCheckFinality;
+function renderToolsDescription(tools) {
+  return tools.map((tool) => {
+    if (tool instanceof BaseTool) {
+      return tool.renderDescription();
+    }
+    return [
+      `Tool Name: ${sanitizeToolName(tool.name)}`,
+      "Tool Arguments: {}",
+      `Tool Description: ${tool.description ?? ""}`
+    ].join("\n");
+  }).join("\n\n");
+}
+function normalizeToolInput(input) {
+  if (input === void 0) {
+    return {};
+  }
+  if (typeof input === "string") {
+    try {
+      const parsed = JSON.parse(input);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : { input };
+    } catch {
+      return { input };
+    }
+  }
+  if (isToolContext(input)) {
+    return { input: input.input, inputs: input.inputs };
+  }
+  return { ...input };
+}
+function normalizeStructuredToolInput(input, argsSchema = null, strictJsonStrings = true) {
+  if (input === void 0) {
+    return {};
+  }
+  if (typeof input === "string") {
+    try {
+      const parsed = JSON.parse(input);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+      const singleArgName = singleSchemaArgName(argsSchema);
+      return singleArgName ? { [singleArgName]: parsed } : {};
+    } catch (error) {
+      const singleArgName = singleSchemaArgName(argsSchema);
+      if (!strictJsonStrings && singleArgName) {
+        return { [singleArgName]: input };
+      }
+      throw new Error(`Failed to parse arguments as JSON: ${error instanceof Error ? error.message : String(error)}`, {
+        cause: error
+      });
+    }
+  }
+  if (isToolContext(input)) {
+    return { input: input.input, inputs: input.inputs };
+  }
+  return { ...input };
+}
+function singleSchemaArgName(argsSchema) {
+  if (!argsSchema) {
+    return null;
+  }
+  const argNames = Object.keys(argsSchema);
+  return argNames.length === 1 ? argNames[0] ?? null : null;
+}
+function jsonDumpsForHint(value) {
+  if (value === null || value === void 0) {
+    return "null";
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => jsonDumpsForHint(item)).join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    return `{${Object.entries(value).map(([key, item]) => `${JSON.stringify(key)}: ${jsonDumpsForHint(item)}`).join(", ")}}`;
+  }
+  return JSON.stringify(value);
+}
+function validateArgs(toolName, schema, args) {
+  const schemaEntries = Object.entries(schema);
+  if (schemaEntries.length === 0) {
+    return { ...args };
+  }
+  const validated = {};
+  for (const [name, spec] of schemaEntries) {
+    const value = args[name];
+    if (value === void 0) {
+      if (spec.default !== void 0) {
+        validated[name] = spec.default;
+        continue;
+      }
+      if (spec.required) {
+        throw new ToolValidationError(`Tool '${toolName}' missing required argument '${name}'.`);
+      }
+      continue;
+    }
+    if (spec.type && spec.type !== "unknown" && !matchesType(value, spec.type)) {
+      throw new ToolValidationError(
+        `Tool '${toolName}' argument '${name}' expected ${spec.type}, got ${Array.isArray(value) ? "array" : typeof value}.`
+      );
+    }
+    validated[name] = value;
+  }
+  return validated;
+}
+function isToolContext(input) {
+  return typeof input.input === "string" && "inputs" in input;
+}
+function matchesType(value, type) {
+  switch (type) {
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+    case "string":
+    case "number":
+    case "boolean":
+      return typeof value === type;
+    case "unknown":
+      return true;
+    default:
+      return false;
+  }
+}
+function buildToolContext(input, inputs) {
+  return { input, inputs };
+}
+function rawToolArgs(input) {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (input === void 0) {
+    return {};
+  }
+  return { ...input };
+}
+async function runPlainToolWithHooks(tool, sanitizedToolName, toolInput, options) {
+  const context = new ToolCallHookContext({
+    toolName: sanitizedToolName,
+    toolInput,
+    tool,
+    agent: options.agent,
+    task: options.task,
+    crew: options.crew
+  });
+  await runBeforeToolCallHooks(context);
+  const rawResult = await tool.run(toolInput);
+  return await runAfterToolCallHooks(new ToolCallHookContext({
+    toolName: sanitizedToolName,
+    toolInput,
+    tool,
+    agent: options.agent,
+    task: options.task,
+    crew: options.crew,
+    toolResult: rawResult
+  }));
+}
+function isToolResultOptions(value) {
+  return value !== null && typeof value === "object" && "result" in value;
+}
+function isToolArgsSchema(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  return Object.values(value).every((entry) => entry !== null && typeof entry === "object" && !Array.isArray(entry));
+}
+function baseToolPassthroughOptions(options) {
+  return {
+    ...options.envVars === void 0 ? {} : { envVars: options.envVars },
+    ...options.env_vars === void 0 ? {} : { env_vars: options.env_vars },
+    ...options.descriptionUpdated === void 0 ? {} : { descriptionUpdated: options.descriptionUpdated },
+    ...options.description_updated === void 0 ? {} : { description_updated: options.description_updated },
+    ...options.resultAsAnswer === void 0 ? {} : { resultAsAnswer: options.resultAsAnswer },
+    ...options.result_as_answer === void 0 ? {} : { result_as_answer: options.result_as_answer },
+    ...options.maxUsageCount === void 0 ? {} : { maxUsageCount: options.maxUsageCount },
+    ...options.max_usage_count === void 0 ? {} : { max_usage_count: options.max_usage_count },
+    ...options.cacheFunction === void 0 ? {} : { cacheFunction: options.cacheFunction },
+    ...options.cache_function === void 0 ? {} : { cache_function: options.cache_function },
+    ...options.cache === void 0 ? {} : { cache: options.cache }
+  };
+}
+function promptLeafToString(value) {
+  return typeof value === "string" ? value : "";
+}
+function toToolString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return value.toString();
+  }
+  return JSON.stringify(value);
+}
+function stringifyToolOutput(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function isPromiseLike2(value) {
+  if (!value || typeof value !== "object" || !("then" in value)) {
+    return false;
+  }
+  return typeof value.then === "function";
+}
+function toolCacheKey(toolName, input) {
+  return `${sanitizeToolName(toolName)}-${input}`;
+}
+function sanitizedCallingName(calling) {
+  return sanitizeToolName(calling.toolName ?? calling.tool_name ?? "");
+}
+function stringifyToolCallingArguments(args) {
+  if (!args) {
+    return "";
+  }
+  return JSON.stringify(args);
+}
+function getRecord(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function getStringProperty(value, key) {
+  const property = getRecord(value)?.[key];
+  return typeof property === "string" ? property : null;
+}
+function getNumberProperty(value, key) {
+  const property = getRecord(value)?.[key];
+  return typeof property === "number" ? property : null;
+}
+function getTaskDisplayName(task) {
+  const name = getStringProperty(task, "name");
+  if (name) {
+    return name;
+  }
+  return getStringProperty(task, "description");
+}
+function getConstructorName(value) {
+  return value && typeof value === "object" ? value.constructor.name : null;
+}
+function incrementTaskToolErrors(task) {
+  const record = getRecord(task);
+  if (!record) {
+    return;
+  }
+  if (typeof record.increment_tools_errors === "function") {
+    record.increment_tools_errors.call(task);
+    return;
+  }
+  if (typeof record.incrementToolsErrors === "function") {
+    record.incrementToolsErrors.call(task);
+    return;
+  }
+  const current = typeof record.tools_errors === "number" ? record.tools_errors : 0;
+  record.tools_errors = current + 1;
+}
+function parseToolInputDictionary(toolInput) {
+  const candidates = [
+    toolInput,
+    toolInput.trim().replaceAll("'", '"'),
+    normalizePythonLiteralObject(toolInput),
+    normalizeJson5LikeObject(toolInput)
+  ].filter((candidate) => typeof candidate === "string");
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function normalizePythonLiteralObject(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+    return null;
+  }
+  return trimmed.replaceAll(/\bTrue\b/g, "true").replaceAll(/\bFalse\b/g, "false").replaceAll(/\bNone\b/g, "null").replaceAll(/'([^'\\]*(?:\\.[^'\\]*)*)'/g, (_match, content) => JSON.stringify(content.replaceAll("\\'", "'")));
+}
+function normalizeJson5LikeObject(value) {
+  const pythonLike = normalizePythonLiteralObject(value);
+  if (!pythonLike) {
+    return null;
+  }
+  return stripTrailingCommas(quoteUnquotedObjectKeys(pythonLike));
+}
+function stripTrailingCommas(value) {
+  let output = "";
+  let inString = false;
+  let escaped = false;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index] ?? "";
+    if (inString) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      output += char;
+      continue;
+    }
+    if (char === ",") {
+      let nextIndex = index + 1;
+      while (/\s/.test(value[nextIndex] ?? "")) {
+        nextIndex += 1;
+      }
+      if (value[nextIndex] === "}" || value[nextIndex] === "]") {
+        continue;
+      }
+    }
+    output += char;
+  }
+  return output;
+}
+function quoteUnquotedObjectKeys(value) {
+  let output = "";
+  let inString = false;
+  let escaped = false;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index] ?? "";
+    if (inString) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      output += char;
+      continue;
+    }
+    if (char === "{" || char === ",") {
+      output += char;
+      let cursor = index + 1;
+      while (/\s/.test(value[cursor] ?? "")) {
+        output += value[cursor] ?? "";
+        cursor += 1;
+      }
+      const keyStart = cursor;
+      if (/[A-Za-z_$]/.test(value[cursor] ?? "")) {
+        cursor += 1;
+        while (/[A-Za-z0-9_$]/.test(value[cursor] ?? "")) {
+          cursor += 1;
+        }
+        let colonCursor = cursor;
+        while (/\s/.test(value[colonCursor] ?? "")) {
+          colonCursor += 1;
+        }
+        if (value[colonCursor] === ":") {
+          output += JSON.stringify(value.slice(keyStart, cursor));
+          index = cursor - 1;
+          continue;
+        }
+      }
+      index = keyStart - 1;
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+function stringifyToolError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return stringifyToolOutput(error);
+}
+function fingerprintToRecord(value) {
+  const record = getRecord(value);
+  if (!record) {
+    return null;
+  }
+  if (typeof record.to_dict === "function") {
+    return record.to_dict.call(value);
+  }
+  if (typeof record.toDict === "function") {
+    return record.toDict.call(value);
+  }
+  return record;
+}
+function setAgentFingerprintFromContext(agent, fingerprintContext) {
+  const record = getRecord(agent);
+  if (!record) {
+    return;
+  }
+  const setter = typeof record.set_fingerprint === "function" ? record.set_fingerprint : typeof record.setFingerprint === "function" ? record.setFingerprint : null;
+  if (!setter) {
+    return;
+  }
+  try {
+    setter.call(agent, Fingerprint.fromDict(fingerprintContext));
+  } catch (error) {
+    throw new Error(`Failed to set fingerprint: ${stringifyToolError(error)}`, { cause: error });
+  }
+}
+function toolNameSimilarity(toolName, sanitizedInput) {
+  return stringSimilarity(sanitizeToolName(toolName), sanitizedInput);
+}
+function stringSimilarity(left, right) {
+  if (left === right) {
+    return 1;
+  }
+  if (left.length === 0 || right.length === 0) {
+    return 0;
+  }
+  const distance = levenshteinDistance(left, right);
+  return 1 - distance / Math.max(left.length, right.length);
+}
+function levenshteinDistance(left, right) {
+  const previous = Array.from({ length: right.length + 1 }, (_value, index) => index);
+  const current = Array.from({ length: right.length + 1 }, () => 0);
+  for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) {
+    current[0] = leftIndex;
+    for (let rightIndex = 1; rightIndex <= right.length; rightIndex += 1) {
+      current[rightIndex] = Math.min(
+        (current[rightIndex - 1] ?? 0) + 1,
+        (previous[rightIndex] ?? 0) + 1,
+        (previous[rightIndex - 1] ?? 0) + (left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1)
+      );
+    }
+    previous.splice(0, previous.length, ...current);
+  }
+  return previous[right.length] ?? 0;
+}
+function inferFunctionParameterNames(func) {
+  return inferFunctionParameters(func).map((parameter) => parameter.name);
+}
+function inferFunctionArgsSchema(func) {
+  return Object.fromEntries(inferFunctionParameters(func).map((parameter) => [
+    parameter.name,
+    parameter.hasDefault ? { type: "unknown", required: false, default: parameter.defaultValue } : { type: "unknown", required: true }
+  ]));
+}
+function inferFunctionParameters(func) {
+  const source = Function.prototype.toString.call(func);
+  const parametersSource = source.match(/^[^(]*\(([^)]*)\)/)?.[1] ?? source.match(/^([^=()]+)=>/)?.[1] ?? "";
+  return parametersSource.split(",").map((parameter) => parameter.trim()).map(parseFunctionParameter).filter((parameter) => parameter !== null && /^[A-Za-z_$][\w$]*$/.test(parameter.name));
+}
+function parseFunctionParameter(parameter) {
+  const [rawName = "", ...defaultParts] = parameter.split("=");
+  const name = rawName.trim();
+  if (!name) {
+    return null;
+  }
+  if (defaultParts.length === 0) {
+    return { name, hasDefault: false };
+  }
+  return { name, hasDefault: true, defaultValue: parseFunctionDefaultValue(defaultParts.join("=").trim()) };
+}
+function parseFunctionDefaultValue(rawDefault) {
+  if (rawDefault === "null") {
+    return null;
+  }
+  if (rawDefault === "undefined") {
+    return void 0;
+  }
+  if (rawDefault === "true") {
+    return true;
+  }
+  if (rawDefault === "false") {
+    return false;
+  }
+  if (/^-?\d+(?:\.\d+)?$/.test(rawDefault)) {
+    return Number(rawDefault);
+  }
+  if (rawDefault.startsWith('"') && rawDefault.endsWith('"') || rawDefault.startsWith("'") && rawDefault.endsWith("'")) {
+    try {
+      return JSON.parse(rawDefault.startsWith("'") ? `"${rawDefault.slice(1, -1).replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : rawDefault);
+    } catch {
+      return rawDefault.slice(1, -1);
+    }
+  }
+  return void 0;
+}
+function inferFunctionDescription(func, name) {
+  if (typeof func !== "object" && typeof func !== "function" || func === null) {
+    return `Tool generated from function ${name}.`;
+  }
+  const propertyDescription = Object.getOwnPropertyDescriptor(func, "description")?.value;
+  if (typeof propertyDescription === "string" && propertyDescription.trim()) {
+    return propertyDescription.trim();
+  }
+  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(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`).join(",")}}`;
+  }
+  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,
+  clearI18NCache,
+  I18N_DEFAULT,
+  get_i18n,
+  clear_i18n_cache,
+  sanitizeToolName,
+  sanitize_tool_name,
+  slugify,
+  _duplicate_separator_pattern,
+  interpolateOnly,
+  interpolate_only,
+  _validate_type,
+  FINAL_ANSWER_ACTION,
+  MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE,
+  MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE,
+  FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE,
+  UNABLE_TO_REPAIR_JSON_RESULTS,
+  AgentAction,
+  AgentFinish,
+  OutputParserError,
+  parseAgentOutput,
+  parse,
+  extractThought,
+  cleanAction,
+  safeRepairJson,
+  parse_agent_output,
+  _extract_thought,
+  _clean_action,
+  _safe_repair_json,
+  CreateConverterKwargs,
+  ConverterError,
+  Converter,
+  validateModel,
+  validate_model,
+  handlePartialJson,
+  handle_partial_json,
+  asyncHandlePartialJson,
+  async_handle_partial_json,
+  convertToModel,
+  convert_to_model,
+  convertWithInstructions,
+  convert_with_instructions,
+  convertWithInstructionsSync,
+  convert_with_instructions_sync,
+  asyncConvertWithInstructions,
+  async_convert_with_instructions,
+  createConverter,
+  create_converter,
+  asyncConvertToModel,
+  async_convert_to_model,
+  getConversionInstructions,
+  get_conversion_instructions,
+  CREW_AI_NAMESPACE,
+  Fingerprint,
+  SecurityConfig,
+  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,
+  InstructorToolCalling,
+  _ArgsSchemaPlaceholder,
+  _default_cache_function,
+  _is_async_callable,
+  _is_awaitable,
+  _serialize_schema,
+  _deserialize_schema,
+  ToolResult,
+  build_schema_hint,
+  ToolUsageLimitExceededError,
+  ToolValidationError,
+  InMemoryToolCache,
+  CacheHandler,
+  ToolsHandler,
+  BaseTool,
+  to_langchain,
+  StructuredTool,
+  CrewStructuredTool,
+  AddImageToolSchema,
+  AddImageTool,
+  ReadFileToolSchema,
+  ReadFileTool,
+  BaseAgentTool,
+  AskQuestionToolSchema,
+  AskQuestionTool,
+  DelegateWorkToolSchema,
+  DelegateWorkTool,
+  AgentTools,
+  CacheTools,
+  MCPNativeTool,
+  MCPToolWrapper,
+  ToolUsageError,
+  ToolUsage,
+  createTool,
+  create_tool,
+  createFunctionTool,
+  create_function_tool,
+  _make_tool,
+  _make_with_name,
+  _resolve_tool_dict,
+  normalizeToolCalling,
+  aexecuteToolAndCheckFinality,
+  aexecute_tool_and_check_finality,
+  executeToolAndCheckFinality,
+  execute_tool_and_check_finality,
+  renderToolsDescription,
+  normalizeToolInput,
+  validateArgs,
+  buildToolContext
+};