@mcp-use/inspector 0.9.0-canary.1 → 0.9.0-canary.2

package/dist/client/assets/{index-DsQI4y0R.js → index-DoWSnGj3.js}

@@ -1,7 +1,7 @@
-import { d as ChatMessage, g as isLangChainTool, q as convertToOpenAITool, r as isZodSchemaV3, s as isZodSchemaV4, l as interopSafeParseAsync, O as OutputParserException, u as BaseCumulativeTransformOutputParser, f as isAIMessage, v as parsePartialJson, _ as __export, m as BaseChatModel, n as getEnvironmentVariable, i as isInteropZodSchema, h as isOpenAITool, S as StructuredOutputParser, J as JsonOutputParser, t as toJsonSchema, w as getSchemaDescription, x as RunnableLambda, R as RunnablePassthrough, o as RunnableSequence, j as isDataContentBlock, k as convertToProviderContentBlock, b as AIMessage, T as ToolMessage, y as HumanMessageChunk, c as AIMessageChunk, z as SystemMessageChunk, F as FunctionMessageChunk, D as ToolMessageChunk, E as ChatMessageChunk, p as parseBase64DataUrl, G as parseMimeType, I as iife, C as ChatGenerationChunk, K as BaseLanguageModel, L as CallbackManager, M as GenerationChunk, N as callbackHandlerPrefersStreaming, P as concat, Q as RUN_KEY, U as isStructuredToolParams, V as isStructuredTool, W as isRunnableToolLike, X as ToolInputParsingException, Y as BaseLangChain, Z as ensureConfig, $ as mergeConfigs, a0 as _isToolCall, a1 as interopParseAsync, a2 as parseCallbackConfigArg, a3 as _configHasToolCallId, a4 as isSimpleStringZodSchema, a5 as validatesOnlyStrings, a6 as patchConfig, a7 as AsyncLocalStorageProviderSingleton, a8 as pickRunnableConfigKeys, a9 as isDirectToolOutput, aa as getAbortSignalError } from "./index-C74kq9On.js";
-import { Z as ZodFirstPartyTypeKind, o as objectType, s as stringType } from "./index-B6TgCktd.js";
-import { t as toJSONSchema, i as parse, q as prettifyError, r as validate } from "./chunk-VL2OQCWN-CX6x4kxU.js";
-import "./embeddings-D88gGGgZ.js";
+import { M as ChatMessage, t as isLangChainTool, a1 as convertToOpenAITool, a2 as ZodFirstPartyTypeKind, a3 as toJSONSchema, a4 as isZodSchemaV3, a5 as isZodSchemaV4, W as BaseChatModel, X as getEnvironmentVariable, j as isInteropZodSchema, P as isOpenAITool, a6 as StructuredOutputParser, Y as JsonOutputParser, H as toJsonSchema, a7 as getSchemaDescription, a8 as RunnableLambda, Z as RunnablePassthrough, $ as RunnableSequence, Q as isDataContentBlock, S as convertToProviderContentBlock, J as AIMessage, o as ToolMessage, a9 as HumanMessageChunk, L as AIMessageChunk, aa as SystemMessageChunk, ab as FunctionMessageChunk, ac as ToolMessageChunk, ad as ChatMessageChunk, U as parseBase64DataUrl, ae as parseMimeType, af as iife, K as ChatGenerationChunk, a as isAIMessage } from "./index-B8yt0GKw.js";
+import { bg as parse } from "./index-BaR5HKmC.js";
+import { J as JsonOutputKeyToolsParser, c as convertLangChainToolCallToOpenAI, p as parseToolCall$2, m as makeInvalidToolCall } from "./index-BLXuIjh0.js";
+import "./embeddings-CF86nH4i.js";
 import "./index-DX0TIfSM.js";
 const iife$1 = (fn) => fn();
 function isReasoningModel(model) {
@@ -45,10 +45,10 @@ function getEndpoint(config) {
   }
   return baseURL;
 }
-function _convertToOpenAITool(tool2, fields) {
+function _convertToOpenAITool(tool, fields) {
   let toolDef;
-  if (isLangChainTool(tool2)) toolDef = convertToOpenAITool(tool2);
-  else toolDef = tool2;
+  if (isLangChainTool(tool)) toolDef = convertToOpenAITool(tool);
+  else toolDef = tool;
   if (fields?.strict !== void 0) toolDef.function.strict = fields.strict;
   return toolDef;
 }
@@ -118,17 +118,17 @@ function formatToOpenAIToolChoice(toolChoice) {
   };
   else return toolChoice;
 }
-function isBuiltInTool(tool2) {
-  return "type" in tool2 && tool2.type !== "function";
+function isBuiltInTool(tool) {
+  return "type" in tool && tool.type !== "function";
 }
 function isBuiltInToolChoice(tool_choice) {
   return tool_choice != null && typeof tool_choice === "object" && "type" in tool_choice && tool_choice.type !== "function";
 }
-function isCustomTool(tool2) {
-  return typeof tool2 === "object" && tool2 !== null && "metadata" in tool2 && typeof tool2.metadata === "object" && tool2.metadata !== null && "customTool" in tool2.metadata && typeof tool2.metadata.customTool === "object" && tool2.metadata.customTool !== null;
+function isCustomTool(tool) {
+  return typeof tool === "object" && tool !== null && "metadata" in tool && typeof tool.metadata === "object" && tool.metadata !== null && "customTool" in tool.metadata && typeof tool.metadata.customTool === "object" && tool.metadata.customTool !== null;
 }
-function isOpenAICustomTool(tool2) {
-  return "type" in tool2 && tool2.type === "custom" && "custom" in tool2 && typeof tool2.custom === "object" && tool2.custom !== null;
+function isOpenAICustomTool(tool) {
+  return "type" in tool && tool.type === "custom" && "custom" in tool && typeof tool.custom === "object" && tool.custom !== null;
 }
 function parseCustomToolCall(rawToolCall) {
   if (rawToolCall.type !== "custom_tool_call") return void 0;
@@ -145,42 +145,42 @@ function parseCustomToolCall(rawToolCall) {
 function isCustomToolCall(toolCall) {
   return toolCall.type === "tool_call" && "isCustomTool" in toolCall && toolCall.isCustomTool === true;
 }
-function convertCompletionsCustomTool(tool2) {
+function convertCompletionsCustomTool(tool) {
   const getFormat = () => {
-    if (!tool2.custom.format) return void 0;
-    if (tool2.custom.format.type === "grammar") return {
+    if (!tool.custom.format) return void 0;
+    if (tool.custom.format.type === "grammar") return {
       type: "grammar",
-      definition: tool2.custom.format.grammar.definition,
-      syntax: tool2.custom.format.grammar.syntax
+      definition: tool.custom.format.grammar.definition,
+      syntax: tool.custom.format.grammar.syntax
     };
-    if (tool2.custom.format.type === "text") return { type: "text" };
+    if (tool.custom.format.type === "text") return { type: "text" };
     return void 0;
   };
   return {
     type: "custom",
-    name: tool2.custom.name,
-    description: tool2.custom.description,
+    name: tool.custom.name,
+    description: tool.custom.description,
     format: getFormat()
   };
 }
-function convertResponsesCustomTool(tool2) {
+function convertResponsesCustomTool(tool) {
   const getFormat = () => {
-    if (!tool2.format) return void 0;
-    if (tool2.format.type === "grammar") return {
+    if (!tool.format) return void 0;
+    if (tool.format.type === "grammar") return {
       type: "grammar",
       grammar: {
-        definition: tool2.format.definition,
-        syntax: tool2.format.syntax
+        definition: tool.format.definition,
+        syntax: tool.format.syntax
       }
     };
-    if (tool2.format.type === "text") return { type: "text" };
+    if (tool.format.type === "text") return { type: "text" };
     return void 0;
   };
   return {
     type: "custom",
     custom: {
-      name: tool2.name,
-      description: tool2.description,
+      name: tool.name,
+      description: tool.description,
       format: getFormat()
     }
   };
@@ -321,8 +321,8 @@ class InvalidWebhookSignatureError extends Error {
     super(message);
   }
 }
-function isChatCompletionFunctionTool(tool2) {
-  return tool2 !== void 0 && "function" in tool2 && tool2.function !== void 0;
+function isChatCompletionFunctionTool(tool) {
+  return tool !== void 0 && "function" in tool && tool.function !== void 0;
 }
 function makeParseableResponseFormat$1(response_format, parser) {
   const obj = { ...response_format };
@@ -341,8 +341,8 @@ function makeParseableResponseFormat$1(response_format, parser) {
 function isAutoParsableResponseFormat(response_format) {
   return response_format?.["$brand"] === "auto-parseable-response-format";
 }
-function isAutoParsableTool$1(tool2) {
-  return tool2?.["$brand"] === "auto-parseable-tool";
+function isAutoParsableTool$1(tool) {
+  return tool?.["$brand"] === "auto-parseable-tool";
 }
 function maybeParseChatCompletion(completion, params) {
   if (!params || !hasAutoParseableInput$1(params)) {
@@ -379,7 +379,7 @@ function parseChatCompletion(completion, params) {
       message: {
         ...choice.message,
         ...choice.message.tool_calls ? {
-          tool_calls: choice.message.tool_calls?.map((toolCall) => parseToolCall$2(params, toolCall)) ?? void 0
+          tool_calls: choice.message.tool_calls?.map((toolCall) => parseToolCall$1(params, toolCall)) ?? void 0
         } : void 0,
         parsed: choice.message.content && !choice.message.refusal ? parseResponseFormat(params, choice.message.content) : null
       }
@@ -400,7 +400,7 @@ function parseResponseFormat(params, content) {
   }
   return null;
 }
-function parseToolCall$2(params, toolCall) {
+function parseToolCall$1(params, toolCall) {
   const inputTool = params.tools?.find((inputTool2) => isChatCompletionFunctionTool(inputTool2) && inputTool2.function?.name === toolCall.function.name);
   return {
     ...toolCall,
@@ -431,12 +431,12 @@ function assertToolCallsAreChatCompletionFunctionToolCalls(toolCalls) {
   }
 }
 function validateInputTools(tools) {
-  for (const tool2 of tools ?? []) {
-    if (tool2.type !== "function") {
-      throw new OpenAIError(`Currently only \`function\` tool types support auto-parsing; Received \`${tool2.type}\``);
+  for (const tool of tools ?? []) {
+    if (tool.type !== "function") {
+      throw new OpenAIError(`Currently only \`function\` tool types support auto-parsing; Received \`${tool.type}\``);
     }
-    if (tool2.function.strict !== true) {
-      throw new OpenAIError(`The \`${tool2.function.name}\` tool is not marked with \`strict: true\`. Only strict function tools can be auto-parsed`);
+    if (tool.function.strict !== true) {
+      throw new OpenAIError(`The \`${tool.function.name}\` tool is not marked with \`strict: true\`. Only strict function tools can be auto-parsed`);
     }
   }
 }
@@ -1602,7 +1602,7 @@ function parseResponse(response, params) {
     if (item.type === "function_call") {
       return {
         ...item,
-        parsed_arguments: parseToolCall$1(params, item)
+        parsed_arguments: parseToolCall(params, item)
       };
     }
     if (item.type === "message") {
@@ -1660,13 +1660,13 @@ function hasAutoParseableInput(params) {
   }
   return false;
 }
-function isAutoParsableTool(tool2) {
-  return tool2?.["$brand"] === "auto-parseable-tool";
+function isAutoParsableTool(tool) {
+  return tool?.["$brand"] === "auto-parseable-tool";
 }
 function getInputToolByName(input_tools, name) {
-  return input_tools.find((tool2) => tool2.type === "function" && tool2.name === name);
+  return input_tools.find((tool) => tool.type === "function" && tool.name === name);
 }
-function parseToolCall$1(params, toolCall) {
+function parseToolCall(params, toolCall) {
   const inputTool = getInputToolByName(params.tools ?? [], toolCall.name);
   return {
     ...toolCall,
@@ -3723,24 +3723,24 @@ class AbstractChatCompletionRunner extends EventStream {
     const { tool_choice = "auto", stream, ...restParams } = params;
     const singleFunctionToCall = typeof tool_choice !== "string" && tool_choice.type === "function" && tool_choice?.function?.name;
     const { maxChatCompletions = DEFAULT_MAX_CHAT_COMPLETIONS } = options || {};
-    const inputTools = params.tools.map((tool2) => {
-      if (isAutoParsableTool$1(tool2)) {
-        if (!tool2.$callback) {
+    const inputTools = params.tools.map((tool) => {
+      if (isAutoParsableTool$1(tool)) {
+        if (!tool.$callback) {
           throw new OpenAIError("Tool given to `.runTools()` that does not have an associated function");
         }
         return {
           type: "function",
           function: {
-            function: tool2.$callback,
-            name: tool2.function.name,
-            description: tool2.function.description || "",
-            parameters: tool2.function.parameters,
-            parse: tool2.$parseRaw,
+            function: tool.$callback,
+            name: tool.function.name,
+            description: tool.function.description || "",
+            parameters: tool.function.parameters,
+            parse: tool.$parseRaw,
             strict: true
           }
         };
       }
-      return tool2;
+      return tool;
     });
     const functionsByName = {};
     for (const f of inputTools) {
@@ -4260,7 +4260,7 @@ class ChatCompletionStream extends AbstractChatCompletionRunner {
       throw new Error("tool call snapshot missing `type`");
     }
     if (toolCallSnapshot.type === "function") {
-      const inputTool = __classPrivateFieldGet(this, _ChatCompletionStream_params, "f")?.tools?.find((tool2) => isChatCompletionFunctionTool(tool2) && tool2.function.name === toolCallSnapshot.function.name);
+      const inputTool = __classPrivateFieldGet(this, _ChatCompletionStream_params, "f")?.tools?.find((tool) => isChatCompletionFunctionTool(tool) && tool.function.name === toolCallSnapshot.function.name);
       this._emit("tool_calls.function.arguments.done", {
         name: toolCallSnapshot.function.name,
         index: toolCallIndex,
@@ -8069,174 +8069,6 @@ OpenAI.Conversations = Conversations;
 OpenAI.Evals = Evals;
 OpenAI.Containers = Containers;
 OpenAI.Videos = Videos;
-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 BaseChatOpenAI = class extends BaseChatModel {
   temperature;
   topP;
@@ -8490,26 +8322,26 @@ var BaseChatOpenAI = class extends BaseChatModel {
     };
     return requestOptions;
   }
-  _convertChatOpenAIToolToCompletionsTool(tool2, fields) {
-    if (isCustomTool(tool2)) return convertResponsesCustomTool(tool2.metadata.customTool);
-    if (isOpenAITool(tool2)) {
+  _convertChatOpenAIToolToCompletionsTool(tool, fields) {
+    if (isCustomTool(tool)) return convertResponsesCustomTool(tool.metadata.customTool);
+    if (isOpenAITool(tool)) {
       if (fields?.strict !== void 0) return {
-        ...tool2,
+        ...tool,
         function: {
-          ...tool2.function,
+          ...tool.function,
           strict: fields.strict
         }
       };
-      return tool2;
+      return tool;
     }
-    return _convertToOpenAITool(tool2, fields);
+    return _convertToOpenAITool(tool, fields);
   }
   bindTools(tools, kwargs) {
     let strict;
     if (kwargs?.strict !== void 0) strict = kwargs.strict;
     else if (this.supportsStrictToolCalling !== void 0) strict = this.supportsStrictToolCalling;
     return this.withConfig({
-      tools: tools.map((tool2) => isBuiltInTool(tool2) || isCustomTool(tool2) ? tool2 : this._convertChatOpenAIToolToCompletionsTool(tool2, { strict })),
+      tools: tools.map((tool) => isBuiltInTool(tool) || isCustomTool(tool) ? tool : this._convertChatOpenAIToolToCompletionsTool(tool, { strict })),
       ...kwargs
     });
   }
@@ -8872,7 +8704,7 @@ const convertCompletionsMessageToBaseMessage = ({ message, rawResponse, includeR
       const toolCalls = [];
       const invalidToolCalls = [];
       for (const rawToolCall of rawToolCalls ?? []) try {
-        toolCalls.push(parseToolCall(rawToolCall, { returnId: true }));
+        toolCalls.push(parseToolCall$2(rawToolCall, { returnId: true }));
       } catch (e) {
         invalidToolCalls.push(makeInvalidToolCall(rawToolCall, e.message));
       }
@@ -9143,7 +8975,7 @@ const convertResponsesMessageToAIMessage = (response) => {
       id: item.call_id
     };
     try {
-      tool_calls.push(parseToolCall(fnAdapter, { returnId: true }));
+      tool_calls.push(parseToolCall$2(fnAdapter, { returnId: true }));
     } catch (e) {
       let errMessage;
       if (typeof e === "object" && e != null && "message" in e && typeof e.message === "string") errMessage = e.message;
@@ -9826,25 +9658,25 @@ var ChatOpenAIResponses = class extends BaseChatOpenAI {
   /** @internal */
   _reduceChatOpenAITools(tools, fields) {
     const reducedTools = [];
-    for (const tool2 of tools) if (isBuiltInTool(tool2)) {
-      if (tool2.type === "image_generation" && fields?.stream) tool2.partial_images = 1;
-      reducedTools.push(tool2);
-    } else if (isCustomTool(tool2)) {
-      const customToolData = tool2.metadata.customTool;
+    for (const tool of tools) if (isBuiltInTool(tool)) {
+      if (tool.type === "image_generation" && fields?.stream) tool.partial_images = 1;
+      reducedTools.push(tool);
+    } else if (isCustomTool(tool)) {
+      const customToolData = tool.metadata.customTool;
       reducedTools.push({
         type: "custom",
         name: customToolData.name,
         description: customToolData.description,
         format: customToolData.format
       });
-    } else if (isOpenAITool(tool2)) reducedTools.push({
+    } else if (isOpenAITool(tool)) reducedTools.push({
       type: "function",
-      name: tool2.function.name,
-      parameters: tool2.function.parameters,
-      description: tool2.function.description,
+      name: tool.function.name,
+      parameters: tool.function.parameters,
+      description: tool.function.description,
       strict: fields?.strict ?? null
     });
-    else if (isOpenAICustomTool(tool2)) reducedTools.push(convertCompletionsCustomTool(tool2));
+    else if (isOpenAICustomTool(tool)) reducedTools.push(convertCompletionsCustomTool(tool));
     return reducedTools;
   }
 };
@@ -9872,7 +9704,7 @@ var ChatOpenAICompletions = class extends BaseChatOpenAI {
       stream: this.streaming,
       functions: options?.functions,
       function_call: options?.function_call,
-      tools: options?.tools?.length ? options.tools.map((tool2) => this._convertChatOpenAIToolToCompletionsTool(tool2, { strict })) : void 0,
+      tools: options?.tools?.length ? options.tools.map((tool) => this._convertChatOpenAIToolToCompletionsTool(tool, { strict })) : void 0,
       tool_choice: formatToOpenAIToolChoice(options?.tool_choice),
       response_format: this._getResponseFormat(options?.response_format),
       seed: options?.seed,
@@ -10146,546 +9978,6 @@ var ChatOpenAI = class ChatOpenAI2 extends BaseChatOpenAI {
     return newModel;
   }
 };
-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 {
   BaseChatOpenAI,
   ChatOpenAI,