@mcp-use/inspector 0.9.0-canary.4 → 0.9.0-canary.5

package/dist/client/assets/index-BumNh2YP.js

@@ -1,725 +0,0 @@
-import { i as interopSafeParseAsync, O as OutputParserException, B as BaseCumulativeTransformOutputParser, a as isAIMessage, p as parsePartialJson, _ as __export, b as BaseLanguageModel, C as CallbackManager, G as GenerationChunk, c as callbackHandlerPrefersStreaming, d as concat, R as RUN_KEY, e as parseCallbackConfigArg, f as BaseLangChain, g as ensureConfig, m as mergeConfigs, h as _isToolCall, j as isInteropZodSchema, k as interopParseAsync, T as ToolInputParsingException, v as validate, l as _configHasToolCallId, n as isDirectToolOutput, o as ToolMessage, q as isStructuredToolParams, r as isStructuredTool, s as isRunnableToolLike, t as isLangChainTool, u as objectType, w as stringType, x as isSimpleStringZodSchema, y as validatesOnlyStrings, z as patchConfig, D as AsyncLocalStorageProviderSingleton, E as pickRunnableConfigKeys, F as getAbortSignalError } from "./index-D-pAR_RA.js";
-import { p as prettifyError } from "./index-DEA0KU_h.js";
-function parseToolCall(rawToolCall, options) {
-  if (rawToolCall.function === void 0) return void 0;
-  let functionArgs;
-  if (options?.partial) try {
-    functionArgs = parsePartialJson(rawToolCall.function.arguments ?? "{}");
-  } catch {
-    return void 0;
-  }
-  else try {
-    functionArgs = JSON.parse(rawToolCall.function.arguments);
-  } catch (e) {
-    throw new OutputParserException([
-      `Function "${rawToolCall.function.name}" arguments:`,
-      ``,
-      rawToolCall.function.arguments,
-      ``,
-      `are not valid JSON.`,
-      `Error: ${e.message}`
-    ].join("\n"));
-  }
-  const parsedToolCall = {
-    name: rawToolCall.function.name,
-    args: functionArgs,
-    type: "tool_call"
-  };
-  if (options?.returnId) parsedToolCall.id = rawToolCall.id;
-  return parsedToolCall;
-}
-function convertLangChainToolCallToOpenAI(toolCall) {
-  if (toolCall.id === void 0) throw new Error(`All OpenAI tool calls must have an "id" field.`);
-  return {
-    id: toolCall.id,
-    type: "function",
-    function: {
-      name: toolCall.name,
-      arguments: JSON.stringify(toolCall.args)
-    }
-  };
-}
-function makeInvalidToolCall(rawToolCall, errorMsg) {
-  return {
-    name: rawToolCall.function?.name,
-    args: rawToolCall.function?.arguments,
-    id: rawToolCall.id,
-    error: errorMsg,
-    type: "invalid_tool_call"
-  };
-}
-var JsonOutputToolsParser = class extends BaseCumulativeTransformOutputParser {
-  static lc_name() {
-    return "JsonOutputToolsParser";
-  }
-  returnId = false;
-  lc_namespace = [
-    "langchain",
-    "output_parsers",
-    "openai_tools"
-  ];
-  lc_serializable = true;
-  constructor(fields) {
-    super(fields);
-    this.returnId = fields?.returnId ?? this.returnId;
-  }
-  _diff() {
-    throw new Error("Not supported.");
-  }
-  async parse() {
-    throw new Error("Not implemented.");
-  }
-  async parseResult(generations) {
-    const result = await this.parsePartialResult(generations, false);
-    return result;
-  }
-  /**
-  * Parses the output and returns a JSON object. If `argsOnly` is true,
-  * only the arguments of the function call are returned.
-  * @param generations The output of the LLM to parse.
-  * @returns A JSON object representation of the function call or its arguments.
-  */
-  async parsePartialResult(generations, partial = true) {
-    const message = generations[0].message;
-    let toolCalls;
-    if (isAIMessage(message) && message.tool_calls?.length) toolCalls = message.tool_calls.map((toolCall) => {
-      const { id, ...rest } = toolCall;
-      if (!this.returnId) return rest;
-      return {
-        id,
-        ...rest
-      };
-    });
-    else if (message.additional_kwargs.tool_calls !== void 0) {
-      const rawToolCalls = JSON.parse(JSON.stringify(message.additional_kwargs.tool_calls));
-      toolCalls = rawToolCalls.map((rawToolCall) => {
-        return parseToolCall(rawToolCall, {
-          returnId: this.returnId,
-          partial
-        });
-      });
-    }
-    if (!toolCalls) return [];
-    const parsedToolCalls = [];
-    for (const toolCall of toolCalls) if (toolCall !== void 0) {
-      const backwardsCompatibleToolCall = {
-        type: toolCall.name,
-        args: toolCall.args,
-        id: toolCall.id
-      };
-      parsedToolCalls.push(backwardsCompatibleToolCall);
-    }
-    return parsedToolCalls;
-  }
-};
-var JsonOutputKeyToolsParser = class extends JsonOutputToolsParser {
-  static lc_name() {
-    return "JsonOutputKeyToolsParser";
-  }
-  lc_namespace = [
-    "langchain",
-    "output_parsers",
-    "openai_tools"
-  ];
-  lc_serializable = true;
-  returnId = false;
-  /** The type of tool calls to return. */
-  keyName;
-  /** Whether to return only the first tool call. */
-  returnSingle = false;
-  zodSchema;
-  constructor(params) {
-    super(params);
-    this.keyName = params.keyName;
-    this.returnSingle = params.returnSingle ?? this.returnSingle;
-    this.zodSchema = params.zodSchema;
-  }
-  async _validateResult(result) {
-    if (this.zodSchema === void 0) return result;
-    const zodParsedResult = await interopSafeParseAsync(this.zodSchema, result);
-    if (zodParsedResult.success) return zodParsedResult.data;
-    else throw new OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error?.issues)}`, JSON.stringify(result, null, 2));
-  }
-  async parsePartialResult(generations) {
-    const results = await super.parsePartialResult(generations);
-    const matchingResults = results.filter((result) => result.type === this.keyName);
-    let returnedValues = matchingResults;
-    if (!matchingResults.length) return void 0;
-    if (!this.returnId) returnedValues = matchingResults.map((result) => result.args);
-    if (this.returnSingle) return returnedValues[0];
-    return returnedValues;
-  }
-  async parseResult(generations) {
-    const results = await super.parsePartialResult(generations, false);
-    const matchingResults = results.filter((result) => result.type === this.keyName);
-    let returnedValues = matchingResults;
-    if (!matchingResults.length) return void 0;
-    if (!this.returnId) returnedValues = matchingResults.map((result) => result.args);
-    if (this.returnSingle) return this._validateResult(returnedValues[0]);
-    const toolCallResults = await Promise.all(returnedValues.map((value) => this._validateResult(value)));
-    return toolCallResults;
-  }
-};
-var openai_tools_exports = {};
-__export(openai_tools_exports, {
-  JsonOutputKeyToolsParser: () => JsonOutputKeyToolsParser,
-  JsonOutputToolsParser: () => JsonOutputToolsParser,
-  convertLangChainToolCallToOpenAI: () => convertLangChainToolCallToOpenAI,
-  makeInvalidToolCall: () => makeInvalidToolCall,
-  parseToolCall: () => parseToolCall
-});
-var llms_exports = {};
-__export(llms_exports, {
-  BaseLLM: () => BaseLLM,
-  LLM: () => LLM
-});
-var BaseLLM = class BaseLLM2 extends BaseLanguageModel {
-  lc_namespace = [
-    "langchain",
-    "llms",
-    this._llmType()
-  ];
-  /**
-  * This method takes an input and options, and returns a string. It
-  * converts the input to a prompt value and generates a result based on
-  * the prompt.
-  * @param input Input for the LLM.
-  * @param options Options for the LLM call.
-  * @returns A string result based on the prompt.
-  */
-  async invoke(input, options) {
-    const promptValue = BaseLLM2._convertInputToPromptValue(input);
-    const result = await this.generatePrompt([promptValue], options, options?.callbacks);
-    return result.generations[0][0].text;
-  }
-  async *_streamResponseChunks(_input, _options, _runManager) {
-    throw new Error("Not implemented.");
-  }
-  _separateRunnableConfigFromCallOptionsCompat(options) {
-    const [runnableConfig, callOptions] = super._separateRunnableConfigFromCallOptions(options);
-    callOptions.signal = runnableConfig.signal;
-    return [runnableConfig, callOptions];
-  }
-  async *_streamIterator(input, options) {
-    if (this._streamResponseChunks === BaseLLM2.prototype._streamResponseChunks) yield this.invoke(input, options);
-    else {
-      const prompt = BaseLLM2._convertInputToPromptValue(input);
-      const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(options);
-      const callbackManager_ = await CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, { verbose: this.verbose });
-      const extra = {
-        options: callOptions,
-        invocation_params: this?.invocationParams(callOptions),
-        batch_size: 1
-      };
-      const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), [prompt.toString()], runnableConfig.runId, void 0, extra, void 0, void 0, runnableConfig.runName);
-      let generation = new GenerationChunk({ text: "" });
-      try {
-        for await (const chunk of this._streamResponseChunks(prompt.toString(), callOptions, runManagers?.[0])) {
-          if (!generation) generation = chunk;
-          else generation = generation.concat(chunk);
-          if (typeof chunk.text === "string") yield chunk.text;
-        }
-      } catch (err) {
-        await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
-        throw err;
-      }
-      await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMEnd({ generations: [[generation]] })));
-    }
-  }
-  /**
-  * This method takes prompt values, options, and callbacks, and generates
-  * a result based on the prompts.
-  * @param promptValues Prompt values for the LLM.
-  * @param options Options for the LLM call.
-  * @param callbacks Callbacks for the LLM call.
-  * @returns An LLMResult based on the prompts.
-  */
-  async generatePrompt(promptValues, options, callbacks) {
-    const prompts = promptValues.map((promptValue) => promptValue.toString());
-    return this.generate(prompts, options, callbacks);
-  }
-  /**
-  * Get the parameters used to invoke the model
-  */
-  invocationParams(_options) {
-    return {};
-  }
-  _flattenLLMResult(llmResult) {
-    const llmResults = [];
-    for (let i = 0; i < llmResult.generations.length; i += 1) {
-      const genList = llmResult.generations[i];
-      if (i === 0) llmResults.push({
-        generations: [genList],
-        llmOutput: llmResult.llmOutput
-      });
-      else {
-        const llmOutput = llmResult.llmOutput ? {
-          ...llmResult.llmOutput,
-          tokenUsage: {}
-        } : void 0;
-        llmResults.push({
-          generations: [genList],
-          llmOutput
-        });
-      }
-    }
-    return llmResults;
-  }
-  /** @ignore */
-  async _generateUncached(prompts, parsedOptions, handledOptions, startedRunManagers) {
-    let runManagers;
-    if (startedRunManagers !== void 0 && startedRunManagers.length === prompts.length) runManagers = startedRunManagers;
-    else {
-      const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
-      const extra = {
-        options: parsedOptions,
-        invocation_params: this?.invocationParams(parsedOptions),
-        batch_size: prompts.length
-      };
-      runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, handledOptions.runId, void 0, extra, void 0, void 0, handledOptions?.runName);
-    }
-    const hasStreamingHandler = !!runManagers?.[0].handlers.find(callbackHandlerPrefersStreaming);
-    let output;
-    if (hasStreamingHandler && prompts.length === 1 && this._streamResponseChunks !== BaseLLM2.prototype._streamResponseChunks) try {
-      const stream = await this._streamResponseChunks(prompts[0], parsedOptions, runManagers?.[0]);
-      let aggregated;
-      for await (const chunk of stream) if (aggregated === void 0) aggregated = chunk;
-      else aggregated = concat(aggregated, chunk);
-      if (aggregated === void 0) throw new Error("Received empty response from chat model call.");
-      output = {
-        generations: [[aggregated]],
-        llmOutput: {}
-      };
-      await runManagers?.[0].handleLLMEnd(output);
-    } catch (e) {
-      await runManagers?.[0].handleLLMError(e);
-      throw e;
-    }
-    else {
-      try {
-        output = await this._generate(prompts, parsedOptions, runManagers?.[0]);
-      } catch (err) {
-        await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
-        throw err;
-      }
-      const flattenedOutputs = this._flattenLLMResult(output);
-      await Promise.all((runManagers ?? []).map((runManager, i) => runManager?.handleLLMEnd(flattenedOutputs[i])));
-    }
-    const runIds = runManagers?.map((manager) => manager.runId) || void 0;
-    Object.defineProperty(output, RUN_KEY, {
-      value: runIds ? { runIds } : void 0,
-      configurable: true
-    });
-    return output;
-  }
-  async _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, runId }) {
-    const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
-    const extra = {
-      options: parsedOptions,
-      invocation_params: this?.invocationParams(parsedOptions),
-      batch_size: prompts.length
-    };
-    const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, runId, void 0, extra, void 0, void 0, handledOptions?.runName);
-    const missingPromptIndices = [];
-    const results = await Promise.allSettled(prompts.map(async (prompt, index) => {
-      const result = await cache.lookup(prompt, llmStringKey);
-      if (result == null) missingPromptIndices.push(index);
-      return result;
-    }));
-    const cachedResults = results.map((result, index) => ({
-      result,
-      runManager: runManagers?.[index]
-    })).filter(({ result }) => result.status === "fulfilled" && result.value != null || result.status === "rejected");
-    const generations = [];
-    await Promise.all(cachedResults.map(async ({ result: promiseResult, runManager }, i) => {
-      if (promiseResult.status === "fulfilled") {
-        const result = promiseResult.value;
-        generations[i] = result.map((result$1) => {
-          result$1.generationInfo = {
-            ...result$1.generationInfo,
-            tokenUsage: {}
-          };
-          return result$1;
-        });
-        if (result.length) await runManager?.handleLLMNewToken(result[0].text);
-        return runManager?.handleLLMEnd({ generations: [result] }, void 0, void 0, void 0, { cached: true });
-      } else {
-        await runManager?.handleLLMError(promiseResult.reason, void 0, void 0, void 0, { cached: true });
-        return Promise.reject(promiseResult.reason);
-      }
-    }));
-    const output = {
-      generations,
-      missingPromptIndices,
-      startedRunManagers: runManagers
-    };
-    Object.defineProperty(output, RUN_KEY, {
-      value: runManagers ? { runIds: runManagers?.map((manager) => manager.runId) } : void 0,
-      configurable: true
-    });
-    return output;
-  }
-  /**
-  * Run the LLM on the given prompts and input, handling caching.
-  */
-  async generate(prompts, options, callbacks) {
-    if (!Array.isArray(prompts)) throw new Error("Argument 'prompts' is expected to be a string[]");
-    let parsedOptions;
-    if (Array.isArray(options)) parsedOptions = { stop: options };
-    else parsedOptions = options;
-    const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptionsCompat(parsedOptions);
-    runnableConfig.callbacks = runnableConfig.callbacks ?? callbacks;
-    if (!this.cache) return this._generateUncached(prompts, callOptions, runnableConfig);
-    const { cache } = this;
-    const llmStringKey = this._getSerializedCacheKeyParametersForCall(callOptions);
-    const { generations, missingPromptIndices, startedRunManagers } = await this._generateCached({
-      prompts,
-      cache,
-      llmStringKey,
-      parsedOptions: callOptions,
-      handledOptions: runnableConfig,
-      runId: runnableConfig.runId
-    });
-    let llmOutput = {};
-    if (missingPromptIndices.length > 0) {
-      const results = await this._generateUncached(missingPromptIndices.map((i) => prompts[i]), callOptions, runnableConfig, startedRunManagers !== void 0 ? missingPromptIndices.map((i) => startedRunManagers?.[i]) : void 0);
-      await Promise.all(results.generations.map(async (generation, index) => {
-        const promptIndex = missingPromptIndices[index];
-        generations[promptIndex] = generation;
-        return cache.update(prompts[promptIndex], llmStringKey, generation);
-      }));
-      llmOutput = results.llmOutput ?? {};
-    }
-    return {
-      generations,
-      llmOutput
-    };
-  }
-  /**
-  * Get the identifying parameters of the LLM.
-  */
-  _identifyingParams() {
-    return {};
-  }
-  _modelType() {
-    return "base_llm";
-  }
-};
-var LLM = class extends BaseLLM {
-  async _generate(prompts, options, runManager) {
-    const generations = await Promise.all(prompts.map((prompt, promptIndex) => this._call(prompt, {
-      ...options,
-      promptIndex
-    }, runManager).then((text) => [{ text }])));
-    return { generations };
-  }
-};
-var tools_exports = {};
-__export(tools_exports, {
-  BaseToolkit: () => BaseToolkit,
-  DynamicStructuredTool: () => DynamicStructuredTool,
-  DynamicTool: () => DynamicTool,
-  StructuredTool: () => StructuredTool,
-  Tool: () => Tool,
-  ToolInputParsingException: () => ToolInputParsingException,
-  isLangChainTool: () => isLangChainTool,
-  isRunnableToolLike: () => isRunnableToolLike,
-  isStructuredTool: () => isStructuredTool,
-  isStructuredToolParams: () => isStructuredToolParams,
-  tool: () => tool
-});
-var StructuredTool = class extends BaseLangChain {
-  /**
-  * Whether to return the tool's output directly.
-  *
-  * Setting this to true means that after the tool is called,
-  * an agent should stop looping.
-  */
-  returnDirect = false;
-  verboseParsingErrors = false;
-  get lc_namespace() {
-    return ["langchain", "tools"];
-  }
-  /**
-  * The tool response format.
-  *
-  * If "content" then the output of the tool is interpreted as the contents of a
-  * ToolMessage. If "content_and_artifact" then the output is expected to be a
-  * two-tuple corresponding to the (content, artifact) of a ToolMessage.
-  *
-  * @default "content"
-  */
-  responseFormat = "content";
-  /**
-  * Default config object for the tool runnable.
-  */
-  defaultConfig;
-  constructor(fields) {
-    super(fields ?? {});
-    this.verboseParsingErrors = fields?.verboseParsingErrors ?? this.verboseParsingErrors;
-    this.responseFormat = fields?.responseFormat ?? this.responseFormat;
-    this.defaultConfig = fields?.defaultConfig ?? this.defaultConfig;
-    this.metadata = fields?.metadata ?? this.metadata;
-  }
-  /**
-  * Invokes the tool with the provided input and configuration.
-  * @param input The input for the tool.
-  * @param config Optional configuration for the tool.
-  * @returns A Promise that resolves with the tool's output.
-  */
-  async invoke(input, config) {
-    let toolInput;
-    let enrichedConfig = ensureConfig(mergeConfigs(this.defaultConfig, config));
-    if (_isToolCall(input)) {
-      toolInput = input.args;
-      enrichedConfig = {
-        ...enrichedConfig,
-        toolCall: input
-      };
-    } else toolInput = input;
-    return this.call(toolInput, enrichedConfig);
-  }
-  /**
-  * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
-  *
-  * Calls the tool with the provided argument, configuration, and tags. It
-  * parses the input according to the schema, handles any errors, and
-  * manages callbacks.
-  * @param arg The input argument for the tool.
-  * @param configArg Optional configuration or callbacks for the tool.
-  * @param tags Optional tags for the tool.
-  * @returns A Promise that resolves with a string.
-  */
-  async call(arg, configArg, tags) {
-    const inputForValidation = _isToolCall(arg) ? arg.args : arg;
-    let parsed;
-    if (isInteropZodSchema(this.schema)) try {
-      parsed = await interopParseAsync(this.schema, inputForValidation);
-    } catch (e) {
-      let message = `Received tool input did not match expected schema`;
-      if (this.verboseParsingErrors) message = `${message}
-Details: ${e.message}`;
-      if (e instanceof Error && e.constructor.name === "ZodError") message = `${message}
-
-${prettifyError(e)}`;
-      throw new ToolInputParsingException(message, JSON.stringify(arg));
-    }
-    else {
-      const result$1 = validate(inputForValidation, this.schema);
-      if (!result$1.valid) {
-        let message = `Received tool input did not match expected schema`;
-        if (this.verboseParsingErrors) message = `${message}
-Details: ${result$1.errors.map((e) => `${e.keywordLocation}: ${e.error}`).join("\n")}`;
-        throw new ToolInputParsingException(message, JSON.stringify(arg));
-      }
-      parsed = inputForValidation;
-    }
-    const config = parseCallbackConfigArg(configArg);
-    const callbackManager_ = CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
-    const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof arg === "string" ? arg : JSON.stringify(arg), config.runId, void 0, void 0, void 0, config.runName);
-    delete config.runId;
-    let result;
-    try {
-      result = await this._call(parsed, runManager, config);
-    } catch (e) {
-      await runManager?.handleToolError(e);
-      throw e;
-    }
-    let content;
-    let artifact;
-    if (this.responseFormat === "content_and_artifact") if (Array.isArray(result) && result.length === 2) [content, artifact] = result;
-    else throw new Error(`Tool response format is "content_and_artifact" but the output was not a two-tuple.
-Result: ${JSON.stringify(result)}`);
-    else content = result;
-    let toolCallId;
-    if (_isToolCall(arg)) toolCallId = arg.id;
-    if (!toolCallId && _configHasToolCallId(config)) toolCallId = config.toolCall.id;
-    const formattedOutput = _formatToolOutput({
-      content,
-      artifact,
-      toolCallId,
-      name: this.name,
-      metadata: this.metadata
-    });
-    await runManager?.handleToolEnd(formattedOutput);
-    return formattedOutput;
-  }
-};
-var Tool = class extends StructuredTool {
-  schema = objectType({ input: stringType().optional() }).transform((obj) => obj.input);
-  constructor(fields) {
-    super(fields);
-  }
-  /**
-  * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
-  *
-  * Calls the tool with the provided argument and callbacks. It handles
-  * string inputs specifically.
-  * @param arg The input argument for the tool, which can be a string, undefined, or an input of the tool's schema.
-  * @param callbacks Optional callbacks for the tool.
-  * @returns A Promise that resolves with a string.
-  */
-  call(arg, callbacks) {
-    const structuredArg = typeof arg === "string" || arg == null ? { input: arg } : arg;
-    return super.call(structuredArg, callbacks);
-  }
-};
-var DynamicTool = class extends Tool {
-  static lc_name() {
-    return "DynamicTool";
-  }
-  name;
-  description;
-  func;
-  constructor(fields) {
-    super(fields);
-    this.name = fields.name;
-    this.description = fields.description;
-    this.func = fields.func;
-    this.returnDirect = fields.returnDirect ?? this.returnDirect;
-  }
-  /**
-  * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
-  */
-  async call(arg, configArg) {
-    const config = parseCallbackConfigArg(configArg);
-    if (config.runName === void 0) config.runName = this.name;
-    return super.call(arg, config);
-  }
-  /** @ignore */
-  async _call(input, runManager, parentConfig) {
-    return this.func(input, runManager, parentConfig);
-  }
-};
-var DynamicStructuredTool = class extends StructuredTool {
-  static lc_name() {
-    return "DynamicStructuredTool";
-  }
-  name;
-  description;
-  func;
-  schema;
-  constructor(fields) {
-    super(fields);
-    this.name = fields.name;
-    this.description = fields.description;
-    this.func = fields.func;
-    this.returnDirect = fields.returnDirect ?? this.returnDirect;
-    this.schema = fields.schema;
-  }
-  /**
-  * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
-  */
-  async call(arg, configArg, tags) {
-    const config = parseCallbackConfigArg(configArg);
-    if (config.runName === void 0) config.runName = this.name;
-    return super.call(arg, config, tags);
-  }
-  _call(arg, runManager, parentConfig) {
-    return this.func(arg, runManager, parentConfig);
-  }
-};
-var BaseToolkit = class {
-  getTools() {
-    return this.tools;
-  }
-};
-function tool(func, fields) {
-  const isSimpleStringSchema = isSimpleStringZodSchema(fields.schema);
-  const isStringJSONSchema = validatesOnlyStrings(fields.schema);
-  if (!fields.schema || isSimpleStringSchema || isStringJSONSchema) return new DynamicTool({
-    ...fields,
-    description: fields.description ?? fields.schema?.description ?? `${fields.name} tool`,
-    func: async (input, runManager, config) => {
-      return new Promise((resolve, reject) => {
-        const childConfig = patchConfig(config, { callbacks: runManager?.getChild() });
-        AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(childConfig), async () => {
-          try {
-            resolve(func(input, childConfig));
-          } catch (e) {
-            reject(e);
-          }
-        });
-      });
-    }
-  });
-  const schema = fields.schema;
-  const description = fields.description ?? fields.schema.description ?? `${fields.name} tool`;
-  return new DynamicStructuredTool({
-    ...fields,
-    description,
-    schema,
-    func: async (input, runManager, config) => {
-      return new Promise((resolve, reject) => {
-        let listener;
-        const cleanup = () => {
-          if (config?.signal && listener) config.signal.removeEventListener("abort", listener);
-        };
-        if (config?.signal) {
-          listener = () => {
-            cleanup();
-            reject(getAbortSignalError(config.signal));
-          };
-          config.signal.addEventListener("abort", listener);
-        }
-        const childConfig = patchConfig(config, { callbacks: runManager?.getChild() });
-        AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(childConfig), async () => {
-          try {
-            const result = await func(input, childConfig);
-            if (config?.signal?.aborted) {
-              cleanup();
-              return;
-            }
-            cleanup();
-            resolve(result);
-          } catch (e) {
-            cleanup();
-            reject(e);
-          }
-        });
-      });
-    }
-  });
-}
-function _formatToolOutput(params) {
-  const { content, artifact, toolCallId, metadata } = params;
-  if (toolCallId && !isDirectToolOutput(content)) if (typeof content === "string" || Array.isArray(content) && content.every((item) => typeof item === "object")) return new ToolMessage({
-    status: "success",
-    content,
-    artifact,
-    tool_call_id: toolCallId,
-    name: params.name,
-    metadata
-  });
-  else return new ToolMessage({
-    status: "success",
-    content: _stringify(content),
-    artifact,
-    tool_call_id: toolCallId,
-    name: params.name,
-    metadata
-  });
-  else return content;
-}
-function _stringify(content) {
-  try {
-    return JSON.stringify(content, null, 2) ?? "";
-  } catch (_noOp) {
-    return `${content}`;
-  }
-}
-export {
-  DynamicTool as D,
-  JsonOutputKeyToolsParser as J,
-  LLM as L,
-  StructuredTool as S,
-  Tool as T,
-  tool as a,
-  DynamicStructuredTool as b,
-  convertLangChainToolCallToOpenAI as c,
-  llms_exports as l,
-  makeInvalidToolCall as m,
-  openai_tools_exports as o,
-  parseToolCall as p,
-  tools_exports as t
-};