langchain 1.0.0-alpha.5 → 1.0.0-alpha.7

package/dist/agents/nodes/AgentNode.js.map

@@ -1 +1 @@
-{"version":3,"file":"AgentNode.js","names":["options: AgentNodeOptions<\n      StateSchema,\n      StructuredResponseFormat,\n      ContextSchema\n    >","#run","#options","#structuredToolInfo","state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"]","config: RunnableConfig","#invokeModel","#areMoreStepsNeeded","options: {\n      lastMessage?: string;\n    }","#deriveModel","#bindTools","#getModelInputState","#handleMultipleStructuredOutputs","#handleSingleStructuredOutput","response: AIMessage","toolCalls: ToolCall[]","#handleToolStrategyError","toolCall: ToolCall","lastMessage?: string","error: ToolStrategyError","response: BaseMessage","model: LanguageModelLike","options: Partial<BaseChatModelCallOptions>"],"sources":["../../../src/agents/nodes/AgentNode.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\nimport { Runnable, RunnableConfig } from \"@langchain/core/runnables\";\nimport { BaseMessage, AIMessage, ToolMessage } from \"@langchain/core/messages\";\nimport { Command } from \"@langchain/langgraph\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type BaseChatModelCallOptions } from \"@langchain/core/language_models/chat_models\";\nimport {\n  InteropZodObject,\n  getSchemaDescription,\n} from \"@langchain/core/utils/types\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\n\nimport { initChatModel } from \"../../chat_models/universal.js\";\nimport { MultipleStructuredOutputsError } from \"../errors.js\";\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport { PreHookAnnotation, AnyAnnotationRoot } from \"../annotation.js\";\nimport { mergeAbortSignals } from \"./utils.js\";\nimport {\n  bindTools,\n  getPromptRunnable,\n  validateLLMHasNoBoundTools,\n  hasToolCalls,\n  hasSupportForJsonSchemaOutput,\n} from \"../utils.js\";\nimport {\n  InternalAgentState,\n  ClientTool,\n  ServerTool,\n  CreateAgentParams,\n} from \"../types.js\";\nimport { withAgentName } from \"../withAgentName.js\";\nimport {\n  ToolStrategy,\n  ProviderStrategy,\n  transformResponseFormat,\n  ToolStrategyError,\n} from \"../responses.js\";\n\ntype ResponseHandlerResult<StructuredResponseFormat> =\n  | {\n      structuredResponse: StructuredResponseFormat;\n      messages: BaseMessage[];\n    }\n  | Promise<Command>;\n\nexport interface AgentNodeOptions<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,\n  StructuredResponseFormat extends Record<string, unknown> = Record<\n    string,\n    unknown\n  >,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n> extends Pick<\n    CreateAgentParams<StateSchema, StructuredResponseFormat, ContextSchema>,\n    \"llm\" | \"model\" | \"prompt\" | \"includeAgentName\" | \"name\" | \"responseFormat\"\n  > {\n  toolClasses: (ClientTool | ServerTool)[];\n  shouldReturnDirect: Set<string>;\n  signal?: AbortSignal;\n}\n\nexport class AgentNode<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,\n  StructuredResponseFormat extends Record<string, unknown> = Record<\n    string,\n    unknown\n  >,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n> extends RunnableCallable<\n  InternalAgentState<StructuredResponseFormat> & PreHookAnnotation[\"State\"],\n  { messages: BaseMessage[] } | { structuredResponse: StructuredResponseFormat }\n> {\n  #options: AgentNodeOptions<\n    StateSchema,\n    StructuredResponseFormat,\n    ContextSchema\n  >;\n\n  #structuredToolInfo: Record<string, ToolStrategy> = {};\n\n  constructor(\n    options: AgentNodeOptions<\n      StateSchema,\n      StructuredResponseFormat,\n      ContextSchema\n    >\n  ) {\n    super({\n      name: options.name ?? \"model\",\n      func: (input, config) =>\n        this.#run(input, config as RunnableConfig) as any,\n    });\n\n    this.#options = options;\n\n    /**\n     * Populate a list of structured tool info.\n     */\n    this.#structuredToolInfo = (\n      transformResponseFormat(this.#options.responseFormat).filter(\n        (format) => format instanceof ToolStrategy\n      ) as ToolStrategy[]\n    ).reduce((acc, format) => {\n      acc[format.name] = format;\n      return acc;\n    }, {} as Record<string, ToolStrategy>);\n  }\n\n  async #run(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ) {\n    /**\n     * Check if we just executed a returnDirect tool\n     * If so, we should generate structured response (if needed) and stop\n     */\n    const lastMessage = state.messages[state.messages.length - 1];\n    if (\n      lastMessage instanceof ToolMessage &&\n      lastMessage.name &&\n      this.#options.shouldReturnDirect.has(lastMessage.name)\n    ) {\n      /**\n       * return directly without invoking the model again\n       */\n      return { messages: [] };\n    }\n\n    const response = await this.#invokeModel(state, config);\n\n    /**\n     * if we were able to generate a structured response, return it\n     */\n    if (\"structuredResponse\" in response) {\n      return {\n        messages: [...state.messages, ...(response.messages || [])],\n        structuredResponse: response.structuredResponse,\n      };\n    }\n\n    /**\n     * if we need to direct the agent to the model, return the update\n     */\n    if (response instanceof Command) {\n      return response;\n    }\n\n    response.name = this.name;\n    response.lc_kwargs.name = this.name;\n\n    if (this.#areMoreStepsNeeded(state, response)) {\n      return {\n        messages: [\n          new AIMessage(\"Sorry, need more steps to process this request.\", {\n            name: this.name,\n            lc_kwargs: { name: this.name },\n            id: response.id,\n          }),\n        ],\n      };\n    }\n\n    return { messages: [response] };\n  }\n\n  /**\n   * Derive the model from the options.\n   * @param state - The state of the agent.\n   * @param config - The config of the agent.\n   * @returns The model.\n   */\n  #deriveModel(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ) {\n    if (this.#options.model) {\n      if (typeof this.#options.model === \"string\") {\n        return initChatModel(this.#options.model);\n      }\n\n      throw new Error(\"`model` option must be a string.\");\n    }\n\n    const model = this.#options.llm;\n\n    /**\n     * If the model is a function, call it to get the model.\n     */\n    if (typeof model === \"function\") {\n      return model(state, config);\n    }\n\n    if (model) {\n      return model;\n    }\n\n    throw new Error(\n      \"No model option was provided, either via `model` or via `llm` option.\"\n    );\n  }\n\n  async #invokeModel(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    config: RunnableConfig,\n    options: {\n      lastMessage?: string;\n    } = {}\n  ): Promise<AIMessage | ResponseHandlerResult<StructuredResponseFormat>> {\n    const model = await this.#deriveModel(state, config);\n\n    /**\n     * Check if the LLM already has bound tools and throw if it does.\n     */\n    validateLLMHasNoBoundTools(model);\n\n    const modelWithTools = await this.#bindTools(model);\n    const modelInput = this.#getModelInputState(state);\n    const signal = mergeAbortSignals(this.#options.signal, config.signal);\n    const invokeConfig = {\n      ...config,\n      signal,\n    };\n\n    const response = (await modelWithTools.invoke(\n      modelInput,\n      invokeConfig\n    )) as AIMessage;\n\n    /**\n     * if the user requests a native schema output, try to parse the response\n     * and return the structured response if it is valid\n     */\n    if (this.#options.responseFormat instanceof ProviderStrategy) {\n      const structuredResponse = this.#options.responseFormat.parse(response);\n      if (structuredResponse) {\n        return { structuredResponse, messages: [response] };\n      }\n    }\n\n    if (!response.tool_calls) {\n      return response;\n    }\n\n    const toolCalls = response.tool_calls.filter(\n      (call) => call.name in this.#structuredToolInfo\n    );\n\n    /**\n     * if there were not structured tool calls, we can return the response\n     */\n    if (toolCalls.length === 0) {\n      return response;\n    }\n\n    /**\n     * if there were multiple structured tool calls, we should throw an error as this\n     * scenario is not defined/supported.\n     */\n    if (toolCalls.length > 1) {\n      return this.#handleMultipleStructuredOutputs(response, toolCalls);\n    }\n\n    const toolStrategy = this.#structuredToolInfo[toolCalls[0].name];\n    const toolMessageContent = toolStrategy?.options?.toolMessageContent;\n    return this.#handleSingleStructuredOutput(\n      response,\n      toolCalls[0],\n      toolMessageContent ?? options.lastMessage\n    );\n  }\n\n  /**\n   * If the model returns multiple structured outputs, we need to handle it.\n   * @param response - The response from the model\n   * @param toolCalls - The tool calls that were made\n   * @returns The response from the model\n   */\n  #handleMultipleStructuredOutputs(\n    response: AIMessage,\n    toolCalls: ToolCall[]\n  ): Promise<Command> {\n    /**\n     * the following should never happen, let's throw an error if it does\n     */\n    if (this.#options.responseFormat instanceof ProviderStrategy) {\n      throw new Error(\n        \"Multiple structured outputs should not apply to native structured output responses\"\n      );\n    }\n\n    const multipleStructuredOutputsError = new MultipleStructuredOutputsError(\n      toolCalls.map((call) => call.name)\n    );\n\n    return this.#handleToolStrategyError(\n      multipleStructuredOutputsError,\n      response,\n      toolCalls[0]\n    );\n  }\n\n  /**\n   * If the model returns a single structured output, we need to handle it.\n   * @param toolCall - The tool call that was made\n   * @returns The structured response and a message to the LLM if needed\n   */\n  #handleSingleStructuredOutput(\n    response: AIMessage,\n    toolCall: ToolCall,\n    lastMessage?: string\n  ): ResponseHandlerResult<StructuredResponseFormat> {\n    const tool = this.#structuredToolInfo[toolCall.name];\n\n    try {\n      const structuredResponse = tool.parse(\n        toolCall.args\n      ) as StructuredResponseFormat;\n\n      return {\n        structuredResponse,\n        messages: [\n          response,\n          new AIMessage(\n            lastMessage ??\n              `Returning structured response: ${JSON.stringify(\n                structuredResponse\n              )}`\n          ),\n        ],\n      };\n    } catch (error) {\n      return this.#handleToolStrategyError(\n        error as ToolStrategyError,\n        response,\n        toolCall\n      );\n    }\n  }\n\n  async #handleToolStrategyError(\n    error: ToolStrategyError,\n    response: AIMessage,\n    toolCall: ToolCall\n  ): Promise<Command> {\n    /**\n     * Using the `errorHandler` option of the first `ToolStrategy` entry is sufficient here.\n     * There is technically only one `ToolStrategy` entry in `structuredToolInfo` if the user\n     * uses `toolStrategy` to define the response format. If the user applies a list of json\n     * schema objects, these will be transformed into multiple `ToolStrategy` entries but all\n     * with the same `handleError` option.\n     */\n    const errorHandler = Object.values(this.#structuredToolInfo).at(0)?.options\n      ?.handleError;\n\n    const toolCallId = toolCall.id;\n    if (!toolCallId) {\n      throw new Error(\n        \"Tool call ID is required to handle tool output errors. Please provide a tool call ID.\"\n      );\n    }\n\n    /**\n     * retry if:\n     */\n    if (\n      /**\n       * if the user has provided `true` as the `errorHandler` option, return a new AIMessage\n       * with the error message and retry the tool call.\n       */\n      (typeof errorHandler === \"boolean\" && errorHandler) ||\n      /**\n       * if `errorHandler` is an array and contains MultipleStructuredOutputsError\n       */\n      (Array.isArray(errorHandler) &&\n        errorHandler.some((h) => h instanceof MultipleStructuredOutputsError))\n    ) {\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content: error.message,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: \"model\",\n      });\n    }\n\n    /**\n     * if `errorHandler` is a string, retry the tool call with given string\n     */\n    if (typeof errorHandler === \"string\") {\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content: errorHandler,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: \"model\",\n      });\n    }\n\n    /**\n     * if `errorHandler` is a function, retry the tool call with the function\n     */\n    if (typeof errorHandler === \"function\") {\n      const content = await errorHandler(error);\n      if (typeof content !== \"string\") {\n        throw new Error(\"Error handler must return a string.\");\n      }\n\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: \"model\",\n      });\n    }\n\n    /**\n     * throw otherwise, e.g. if `errorHandler` is not defined or set to `false`\n     */\n    throw error;\n  }\n\n  #areMoreStepsNeeded(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    response: BaseMessage\n  ): boolean {\n    const allToolsReturnDirect =\n      response instanceof AIMessage &&\n      response.tool_calls?.every((call) =>\n        this.#options.shouldReturnDirect.has(call.name)\n      );\n    const remainingSteps =\n      \"remainingSteps\" in state ? (state.remainingSteps as number) : undefined;\n    return Boolean(\n      remainingSteps &&\n        ((remainingSteps < 1 && allToolsReturnDirect) ||\n          (remainingSteps < 2 && hasToolCalls(state.messages)))\n    );\n  }\n\n  #getModelInputState(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"]\n  ): Omit<InternalAgentState<StructuredResponseFormat>, \"llmInputMessages\"> {\n    const { messages, llmInputMessages, ...rest } = state;\n    if (llmInputMessages && llmInputMessages.length > 0) {\n      return { messages: llmInputMessages, ...rest } as Omit<\n        InternalAgentState<StructuredResponseFormat>,\n        \"llmInputMessages\"\n      >;\n    }\n    return { messages, ...rest } as Omit<\n      InternalAgentState<StructuredResponseFormat>,\n      \"llmInputMessages\"\n    >;\n  }\n\n  async #bindTools(model: LanguageModelLike): Promise<Runnable> {\n    const options: Partial<BaseChatModelCallOptions> = {};\n    const structuredTools = Object.values(this.#structuredToolInfo);\n    const allTools = this.#options.toolClasses.concat(\n      ...structuredTools.map((toolStrategy) => toolStrategy.tool)\n    );\n\n    /**\n     * If there are structured tools, we need to set the tool choice to \"any\"\n     * so that the model can choose to use a structured tool or not.\n     */\n    const toolChoice = structuredTools.length > 0 ? \"any\" : undefined;\n\n    /**\n     * check if the user requests a native schema output\n     */\n    if (this.#options.responseFormat instanceof ProviderStrategy) {\n      /**\n       * if the model does not support JSON schema output, throw an error\n       */\n      if (!hasSupportForJsonSchemaOutput(model)) {\n        throw new Error(\n          \"Model does not support native structured output responses. Please use a model that supports native structured output responses or use a tool output.\"\n        );\n      }\n\n      const jsonSchemaParams = {\n        name: this.#options.responseFormat.schema?.name ?? \"extract\",\n        description: getSchemaDescription(this.#options.responseFormat.schema),\n        schema: this.#options.responseFormat.schema,\n        strict: true,\n      };\n\n      Object.assign(options, {\n        response_format: {\n          type: \"json_schema\",\n          json_schema: jsonSchemaParams,\n        },\n        ls_structured_output_format: {\n          kwargs: { method: \"json_schema\" },\n          schema: this.#options.responseFormat.schema,\n        },\n        strict: true,\n      });\n    }\n\n    /**\n     * Bind tools to the model if they are not already bound.\n     */\n    const modelWithTools = await bindTools(model, allTools, {\n      ...options,\n      tool_choice: toolChoice,\n    });\n\n    /**\n     * Create a model runnable with the prompt and agent name\n     */\n    const modelRunnable = getPromptRunnable(this.#options.prompt).pipe(\n      this.#options.includeAgentName === \"inline\"\n        ? withAgentName(modelWithTools, this.#options.includeAgentName)\n        : modelWithTools\n    );\n\n    return modelRunnable;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"AgentNode.js","names":["options: AgentNodeOptions<\n      StateSchema,\n      StructuredResponseFormat,\n      ContextSchema\n    >","#run","#options","model: string | LanguageModelLike","state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"]","config: RunnableConfig","#invokeModel","#areMoreStepsNeeded","options: {\n      lastMessage?: string;\n    }","#deriveModel","#getResponseFormat","#bindTools","#getModelInputState","#handleMultipleStructuredOutputs","#handleSingleStructuredOutput","response: AIMessage","toolCalls: ToolCall[]","structuredResponseFormat: ToolResponseFormat","#handleToolStrategyError","toolCall: ToolCall","lastMessage?: string","error: ToolStrategyError","response: BaseMessage","model: LanguageModelLike","structuredResponseFormat: ResponseFormat | undefined","options: Partial<BaseChatModelCallOptions>"],"sources":["../../../src/agents/nodes/AgentNode.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\nimport { Runnable, RunnableConfig } from \"@langchain/core/runnables\";\nimport { BaseMessage, AIMessage, ToolMessage } from \"@langchain/core/messages\";\nimport { Command } from \"@langchain/langgraph\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type BaseChatModelCallOptions } from \"@langchain/core/language_models/chat_models\";\nimport {\n  InteropZodObject,\n  getSchemaDescription,\n} from \"@langchain/core/utils/types\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\n\nimport { initChatModel } from \"../../chat_models/universal.js\";\nimport { MultipleStructuredOutputsError } from \"../errors.js\";\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport { PreHookAnnotation, AnyAnnotationRoot } from \"../annotation.js\";\nimport { mergeAbortSignals } from \"./utils.js\";\nimport {\n  bindTools,\n  getPromptRunnable,\n  validateLLMHasNoBoundTools,\n  hasToolCalls,\n} from \"../utils.js\";\nimport {\n  InternalAgentState,\n  ClientTool,\n  ServerTool,\n  CreateAgentParams,\n} from \"../types.js\";\nimport { withAgentName } from \"../withAgentName.js\";\nimport {\n  ToolStrategy,\n  ProviderStrategy,\n  transformResponseFormat,\n  ToolStrategyError,\n  hasSupportForJsonSchemaOutput,\n} from \"../responses.js\";\n\ntype ResponseHandlerResult<StructuredResponseFormat> =\n  | {\n      structuredResponse: StructuredResponseFormat;\n      messages: BaseMessage[];\n    }\n  | Promise<Command>;\n\nexport interface AgentNodeOptions<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,\n  StructuredResponseFormat extends Record<string, unknown> = Record<\n    string,\n    unknown\n  >,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n> extends Pick<\n    CreateAgentParams<StateSchema, StructuredResponseFormat, ContextSchema>,\n    \"llm\" | \"model\" | \"prompt\" | \"includeAgentName\" | \"name\" | \"responseFormat\"\n  > {\n  toolClasses: (ClientTool | ServerTool)[];\n  shouldReturnDirect: Set<string>;\n  signal?: AbortSignal;\n}\n\ninterface NativeResponseFormat {\n  type: \"native\";\n  strategy: ProviderStrategy;\n}\n\ninterface ToolResponseFormat {\n  type: \"tool\";\n  tools: Record<string, ToolStrategy>;\n}\n\ntype ResponseFormat = NativeResponseFormat | ToolResponseFormat;\n\nexport class AgentNode<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,\n  StructuredResponseFormat extends Record<string, unknown> = Record<\n    string,\n    unknown\n  >,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n> extends RunnableCallable<\n  InternalAgentState<StructuredResponseFormat> & PreHookAnnotation[\"State\"],\n  { messages: BaseMessage[] } | { structuredResponse: StructuredResponseFormat }\n> {\n  #options: AgentNodeOptions<\n    StateSchema,\n    StructuredResponseFormat,\n    ContextSchema\n  >;\n\n  constructor(\n    options: AgentNodeOptions<\n      StateSchema,\n      StructuredResponseFormat,\n      ContextSchema\n    >\n  ) {\n    super({\n      name: options.name ?? \"model\",\n      func: (input, config) =>\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        this.#run(input, config as RunnableConfig) as any,\n    });\n\n    this.#options = options;\n  }\n\n  /**\n   * Returns response format primtivies based on given model and response format provided by the user.\n   *\n   * If the the user selects a tool output:\n   * - return a record of tools to extract structured output from the model's response\n   *\n   * if the the user selects a native schema output or if the model supports JSON schema output:\n   * - return a provider strategy to extract structured output from the model's response\n   *\n   * @param model - The model to get the response format for.\n   * @returns The response format.\n   */\n  #getResponseFormat(\n    model: string | LanguageModelLike\n  ): ResponseFormat | undefined {\n    if (!this.#options.responseFormat) {\n      return undefined;\n    }\n\n    const strategies = transformResponseFormat(\n      this.#options.responseFormat,\n      undefined,\n      model\n    );\n\n    /**\n     * we either define a list of provider strategies or a list of tool strategies\n     */\n    const isProviderStrategy = strategies.every(\n      (format) => format instanceof ProviderStrategy\n    );\n\n    /**\n     * Populate a list of structured tool info.\n     */\n    if (!isProviderStrategy) {\n      return {\n        type: \"tool\",\n        tools: (\n          strategies.filter(\n            (format) => format instanceof ToolStrategy\n          ) as ToolStrategy[]\n        ).reduce((acc, format) => {\n          acc[format.name] = format;\n          return acc;\n        }, {} as Record<string, ToolStrategy>),\n      };\n    }\n\n    return {\n      type: \"native\",\n      /**\n       * there can only be one provider strategy\n       */\n      strategy: strategies[0],\n    };\n  }\n\n  async #run(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ) {\n    /**\n     * Check if we just executed a returnDirect tool\n     * If so, we should generate structured response (if needed) and stop\n     */\n    const lastMessage = state.messages[state.messages.length - 1];\n    if (\n      ToolMessage.isInstance(lastMessage) &&\n      lastMessage.name &&\n      this.#options.shouldReturnDirect.has(lastMessage.name)\n    ) {\n      /**\n       * return directly without invoking the model again\n       */\n      return { messages: [] };\n    }\n\n    const response = await this.#invokeModel(state, config);\n\n    /**\n     * if we were able to generate a structured response, return it\n     */\n    if (\"structuredResponse\" in response) {\n      return {\n        messages: [...state.messages, ...(response.messages || [])],\n        structuredResponse: response.structuredResponse,\n      };\n    }\n\n    /**\n     * if we need to direct the agent to the model, return the update\n     */\n    if (response instanceof Command) {\n      return response;\n    }\n\n    response.name = this.name;\n    response.lc_kwargs.name = this.name;\n\n    if (this.#areMoreStepsNeeded(state, response)) {\n      return {\n        messages: [\n          new AIMessage({\n            content: \"Sorry, need more steps to process this request.\",\n            name: this.name,\n            id: response.id,\n          }),\n        ],\n      };\n    }\n\n    return { messages: [response] };\n  }\n\n  /**\n   * Derive the model from the options.\n   * @param state - The state of the agent.\n   * @param config - The config of the agent.\n   * @returns The model.\n   */\n  #deriveModel(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ) {\n    if (this.#options.model) {\n      if (typeof this.#options.model === \"string\") {\n        return initChatModel(this.#options.model);\n      }\n\n      throw new Error(\"`model` option must be a string.\");\n    }\n\n    const model = this.#options.llm;\n\n    /**\n     * If the model is a function, call it to get the model.\n     */\n    if (typeof model === \"function\") {\n      return model(state, config);\n    }\n\n    if (model) {\n      return model;\n    }\n\n    throw new Error(\n      \"No model option was provided, either via `model` or via `llm` option.\"\n    );\n  }\n\n  async #invokeModel(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    config: RunnableConfig,\n    options: {\n      lastMessage?: string;\n    } = {}\n  ): Promise<AIMessage | ResponseHandlerResult<StructuredResponseFormat>> {\n    const model = await this.#deriveModel(state, config);\n\n    /**\n     * Check if the LLM already has bound tools and throw if it does.\n     */\n    validateLLMHasNoBoundTools(model);\n\n    const structuredResponseFormat = this.#getResponseFormat(model);\n    const modelWithTools = await this.#bindTools(\n      model,\n      structuredResponseFormat\n    );\n    const modelInput = this.#getModelInputState(state);\n    const signal = mergeAbortSignals(this.#options.signal, config.signal);\n    const invokeConfig = {\n      ...config,\n      signal,\n    };\n\n    const response = (await modelWithTools.invoke(\n      modelInput,\n      invokeConfig\n    )) as AIMessage;\n\n    /**\n     * if the user requests a native schema output, try to parse the response\n     * and return the structured response if it is valid\n     */\n    if (structuredResponseFormat?.type === \"native\") {\n      const structuredResponse =\n        structuredResponseFormat.strategy.parse(response);\n      if (structuredResponse) {\n        return { structuredResponse, messages: [response] };\n      }\n\n      return response;\n    }\n\n    if (!structuredResponseFormat || !response.tool_calls) {\n      return response;\n    }\n\n    const toolCalls = response.tool_calls.filter(\n      (call) => call.name in structuredResponseFormat.tools\n    );\n\n    /**\n     * if there were not structured tool calls, we can return the response\n     */\n    if (toolCalls.length === 0) {\n      return response;\n    }\n\n    /**\n     * if there were multiple structured tool calls, we should throw an error as this\n     * scenario is not defined/supported.\n     */\n    if (toolCalls.length > 1) {\n      return this.#handleMultipleStructuredOutputs(\n        response,\n        toolCalls,\n        structuredResponseFormat\n      );\n    }\n\n    const toolStrategy = structuredResponseFormat.tools[toolCalls[0].name];\n    const toolMessageContent = toolStrategy?.options?.toolMessageContent;\n    return this.#handleSingleStructuredOutput(\n      response,\n      toolCalls[0],\n      structuredResponseFormat,\n      toolMessageContent ?? options.lastMessage\n    );\n  }\n\n  /**\n   * If the model returns multiple structured outputs, we need to handle it.\n   * @param response - The response from the model\n   * @param toolCalls - The tool calls that were made\n   * @returns The response from the model\n   */\n  #handleMultipleStructuredOutputs(\n    response: AIMessage,\n    toolCalls: ToolCall[],\n    structuredResponseFormat: ToolResponseFormat\n  ): Promise<Command> {\n    /**\n     * the following should never happen, let's throw an error if it does\n     */\n    if (this.#options.responseFormat instanceof ProviderStrategy) {\n      throw new Error(\n        \"Multiple structured outputs should not apply to native structured output responses\"\n      );\n    }\n\n    const multipleStructuredOutputsError = new MultipleStructuredOutputsError(\n      toolCalls.map((call) => call.name)\n    );\n\n    return this.#handleToolStrategyError(\n      multipleStructuredOutputsError,\n      response,\n      toolCalls[0],\n      structuredResponseFormat\n    );\n  }\n\n  /**\n   * If the model returns a single structured output, we need to handle it.\n   * @param toolCall - The tool call that was made\n   * @returns The structured response and a message to the LLM if needed\n   */\n  #handleSingleStructuredOutput(\n    response: AIMessage,\n    toolCall: ToolCall,\n    structuredResponseFormat: ToolResponseFormat,\n    lastMessage?: string\n  ): ResponseHandlerResult<StructuredResponseFormat> {\n    const tool = structuredResponseFormat.tools[toolCall.name];\n\n    try {\n      const structuredResponse = tool.parse(\n        toolCall.args\n      ) as StructuredResponseFormat;\n\n      return {\n        structuredResponse,\n        messages: [\n          response,\n          new AIMessage(\n            lastMessage ??\n              `Returning structured response: ${JSON.stringify(\n                structuredResponse\n              )}`\n          ),\n        ],\n      };\n    } catch (error) {\n      return this.#handleToolStrategyError(\n        error as ToolStrategyError,\n        response,\n        toolCall,\n        structuredResponseFormat\n      );\n    }\n  }\n\n  async #handleToolStrategyError(\n    error: ToolStrategyError,\n    response: AIMessage,\n    toolCall: ToolCall,\n    structuredResponseFormat: ToolResponseFormat\n  ): Promise<Command> {\n    /**\n     * Using the `errorHandler` option of the first `ToolStrategy` entry is sufficient here.\n     * There is technically only one `ToolStrategy` entry in `structuredToolInfo` if the user\n     * uses `toolStrategy` to define the response format. If the user applies a list of json\n     * schema objects, these will be transformed into multiple `ToolStrategy` entries but all\n     * with the same `handleError` option.\n     */\n    const errorHandler = Object.values(structuredResponseFormat.tools).at(0)\n      ?.options?.handleError;\n\n    const toolCallId = toolCall.id;\n    if (!toolCallId) {\n      throw new Error(\n        \"Tool call ID is required to handle tool output errors. Please provide a tool call ID.\"\n      );\n    }\n\n    /**\n     * retry if:\n     */\n    if (\n      /**\n       * if the user has provided `true` as the `errorHandler` option, return a new AIMessage\n       * with the error message and retry the tool call.\n       */\n      (typeof errorHandler === \"boolean\" && errorHandler) ||\n      /**\n       * if `errorHandler` is an array and contains MultipleStructuredOutputsError\n       */\n      (Array.isArray(errorHandler) &&\n        errorHandler.some((h) => h instanceof MultipleStructuredOutputsError))\n    ) {\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content: error.message,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: \"model\",\n      });\n    }\n\n    /**\n     * if `errorHandler` is a string, retry the tool call with given string\n     */\n    if (typeof errorHandler === \"string\") {\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content: errorHandler,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: \"model\",\n      });\n    }\n\n    /**\n     * if `errorHandler` is a function, retry the tool call with the function\n     */\n    if (typeof errorHandler === \"function\") {\n      const content = await errorHandler(error);\n      if (typeof content !== \"string\") {\n        throw new Error(\"Error handler must return a string.\");\n      }\n\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: \"model\",\n      });\n    }\n\n    /**\n     * throw otherwise, e.g. if `errorHandler` is not defined or set to `false`\n     */\n    throw error;\n  }\n\n  #areMoreStepsNeeded(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"],\n    response: BaseMessage\n  ): boolean {\n    const allToolsReturnDirect =\n      AIMessage.isInstance(response) &&\n      response.tool_calls?.every((call) =>\n        this.#options.shouldReturnDirect.has(call.name)\n      );\n    const remainingSteps =\n      \"remainingSteps\" in state ? (state.remainingSteps as number) : undefined;\n    return Boolean(\n      remainingSteps &&\n        ((remainingSteps < 1 && allToolsReturnDirect) ||\n          (remainingSteps < 2 && hasToolCalls(state.messages)))\n    );\n  }\n\n  #getModelInputState(\n    state: InternalAgentState<StructuredResponseFormat> &\n      PreHookAnnotation[\"State\"]\n  ): Omit<InternalAgentState<StructuredResponseFormat>, \"llmInputMessages\"> {\n    const { messages, llmInputMessages, ...rest } = state;\n    if (llmInputMessages && llmInputMessages.length > 0) {\n      return { messages: llmInputMessages, ...rest } as Omit<\n        InternalAgentState<StructuredResponseFormat>,\n        \"llmInputMessages\"\n      >;\n    }\n    return { messages, ...rest } as Omit<\n      InternalAgentState<StructuredResponseFormat>,\n      \"llmInputMessages\"\n    >;\n  }\n\n  async #bindTools(\n    model: LanguageModelLike,\n    structuredResponseFormat: ResponseFormat | undefined\n  ): Promise<Runnable> {\n    const options: Partial<BaseChatModelCallOptions> = {};\n    const structuredTools =\n      structuredResponseFormat?.type === \"tool\"\n        ? Object.values(structuredResponseFormat.tools)\n        : [];\n    const allTools = this.#options.toolClasses.concat(\n      ...structuredTools.map((toolStrategy) => toolStrategy.tool)\n    );\n\n    /**\n     * If there are structured tools, we need to set the tool choice to \"any\"\n     * so that the model can choose to use a structured tool or not.\n     */\n    const toolChoice = structuredTools.length > 0 ? \"any\" : undefined;\n\n    /**\n     * check if the user requests a native schema output\n     */\n    if (structuredResponseFormat?.type === \"native\") {\n      /**\n       * if the model does not support JSON schema output, throw an error\n       */\n      if (!hasSupportForJsonSchemaOutput(model)) {\n        throw new Error(\n          \"Model does not support native structured output responses. Please use a model that supports native structured output responses or use a tool output.\"\n        );\n      }\n\n      const jsonSchemaParams = {\n        name: structuredResponseFormat.strategy.schema?.name ?? \"extract\",\n        description: getSchemaDescription(\n          structuredResponseFormat.strategy.schema\n        ),\n        schema: structuredResponseFormat.strategy.schema,\n        strict: true,\n      };\n\n      Object.assign(options, {\n        response_format: {\n          type: \"json_schema\",\n          json_schema: jsonSchemaParams,\n        },\n        ls_structured_output_format: {\n          kwargs: { method: \"json_schema\" },\n          schema: structuredResponseFormat.strategy.schema,\n        },\n        strict: true,\n      });\n    }\n\n    /**\n     * Bind tools to the model if they are not already bound.\n     */\n    const modelWithTools = await bindTools(model, allTools, {\n      ...options,\n      tool_choice: toolChoice,\n    });\n\n    /**\n     * Create a model runnable with the prompt and agent name\n     */\n    const modelRunnable = getPromptRunnable(this.#options.prompt).pipe(\n      this.#options.includeAgentName === \"inline\"\n        ? withAgentName(modelWithTools, this.#options.includeAgentName)\n        : modelWithTools\n    );\n\n    return modelRunnable;\n  }\n}\n"],"mappings":"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"}

package/dist/agents/nodes/ToolNode.cjs

@@ -18,7 +18,7 @@ const isSendInput = (input) => typeof input === "object" && input != null && "lg
 * @example
 * ```ts
 * import { ToolNode, tool, AIMessage } from "langchain";
-* import { z } from "zod";
+* import { z } from "zod/v3";
 *
 * const getWeather = tool((input) => {
 *   if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
@@ -82,7 +82,7 @@ var ToolNode = class extends require_RunnableCallable.RunnableCallable {
 				...config,
 				signal: require_utils.mergeAbortSignals(this.signal, config.signal)
 			});
-			if ((0, __langchain_core_messages.isBaseMessage)(output) && output.getType() === "tool" || (0, __langchain_langgraph.isCommand)(output)) return output;
+			if (__langchain_core_messages.ToolMessage.isInstance(output) || (0, __langchain_langgraph.isCommand)(output)) return output;
 			return new __langchain_core_messages.ToolMessage({
 				name: tool.name,
 				content: typeof output === "string" ? output : JSON.stringify(output),
@@ -138,12 +138,12 @@ var ToolNode = class extends require_RunnableCallable.RunnableCallable {
 			let aiMessage;
 			for (let i = messages.length - 1; i >= 0; i -= 1) {
 				const message = messages[i];
-				if (message.getType() === "ai") {
+				if (__langchain_core_messages.AIMessage.isInstance(message)) {
 					aiMessage = message;
 					break;
 				}
 			}
-			if (aiMessage?.getType() !== "ai") throw new Error("ToolNode only accepts AIMessages as input.");
+			if (!__langchain_core_messages.AIMessage.isInstance(aiMessage)) throw new Error("ToolNode only accepts AIMessages as input.");
 			outputs = await Promise.all(aiMessage.tool_calls?.filter((call) => call.id == null || !toolMessageIds.has(call.id)).map((call) => this.runTool(call, config)) ?? []);
 		}
 		if (!outputs.some(__langchain_langgraph.isCommand)) return Array.isArray(state) ? outputs : { messages: outputs };

package/dist/agents/nodes/ToolNode.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ToolNode.cjs","names":["input: unknown","isBaseMessage","RunnableCallable","tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[]","options?: ToolNodeOptions","call: ToolCall","config: RunnableConfig","tool","mergeAbortSignals","ToolMessage","e: unknown","ToolInputParsingException","ToolInvocationError","state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"]","outputs: (ToolMessage | Command)[]","messages: BaseMessage[]","toolMessageIds: Set<string>","aiMessage: AIMessage | undefined","isCommand","combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[]","parentCommand: Command | null","Command","x: unknown","Send"],"sources":["../../../src/agents/nodes/ToolNode.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\nimport {\n  BaseMessage,\n  ToolMessage,\n  AIMessage,\n  isBaseMessage,\n  isToolMessage,\n} from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport {\n  DynamicTool,\n  StructuredToolInterface,\n  ToolInputParsingException,\n} from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  isCommand,\n  Command,\n  Send,\n  isGraphInterrupt,\n  type NodeInterrupt,\n} from \"@langchain/langgraph\";\n\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport {\n  PreHookAnnotation,\n  AnyAnnotationRoot,\n  ToAnnotationRoot,\n} from \"../annotation.js\";\nimport { mergeAbortSignals } from \"./utils.js\";\nimport { ToolInvocationError } from \"../errors.js\";\n\nexport interface ToolNodeOptions {\n  /**\n   * The name of the tool node.\n   */\n  name?: string;\n  /**\n   * The tags to add to the tool call.\n   */\n  tags?: string[];\n  /**\n   * The abort signal to cancel the tool call.\n   */\n  signal?: AbortSignal;\n  /**\n   * Whether to throw the error immediately if the tool fails or handle it by the `onToolError` function or via ToolMessage.\n   *\n   * If `true` (default):\n   *   - a tool message with the error will be returned to the LLM\n   *\n   * If `false`:\n   *   - the error will be thrown immediately\n   *\n   * If a function is provided:\n   *   - returns a custom {@link ToolMessage} as result\n   *   - throws an error otherwise\n   *\n   * @default true\n   */\n  handleToolErrors?:\n    | boolean\n    | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n}\n\nconst isBaseMessageArray = (input: unknown): input is BaseMessage[] =>\n  Array.isArray(input) && input.every(isBaseMessage);\n\nconst isMessagesState = (\n  input: unknown\n): input is { messages: BaseMessage[] } =>\n  typeof input === \"object\" &&\n  input != null &&\n  \"messages\" in input &&\n  isBaseMessageArray(input.messages);\n\nconst isSendInput = (input: unknown): input is { lg_tool_call: ToolCall } =>\n  typeof input === \"object\" && input != null && \"lg_tool_call\" in input;\n\n/**\n * `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.\n * It works seamlessly with `createAgent`, offering advanced tool execution control, built\n * in parallelism, and error handling.\n *\n * @example\n * ```ts\n * import { ToolNode, tool, AIMessage } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class ToolNode<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = any,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = any\n> extends RunnableCallable<StateSchema, ContextSchema> {\n  tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n\n  trace = false;\n\n  signal?: AbortSignal;\n\n  handleToolErrors:\n    | boolean\n    | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined) = true;\n\n  constructor(\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[],\n    public options?: ToolNodeOptions\n  ) {\n    const { name, tags, handleToolErrors } = options ?? {};\n    super({\n      name,\n      tags,\n      func: (state, config) =>\n        this.run(\n          state as ToAnnotationRoot<StateSchema>[\"State\"] &\n            PreHookAnnotation[\"State\"],\n          config as RunnableConfig\n        ),\n    });\n    this.tools = tools;\n    this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;\n    this.signal = options?.signal;\n  }\n\n  protected async runTool(\n    call: ToolCall,\n    config: RunnableConfig\n  ): Promise<ToolMessage | Command> {\n    const tool = this.tools.find((tool) => tool.name === call.name);\n    try {\n      if (tool === undefined) {\n        throw new Error(`Tool \"${call.name}\" not found.`);\n      }\n\n      const output = await tool.invoke(\n        { ...call, type: \"tool_call\" },\n        {\n          ...config,\n          signal: mergeAbortSignals(this.signal, config.signal),\n        }\n      );\n\n      if (\n        (isBaseMessage(output) && output.getType() === \"tool\") ||\n        isCommand(output)\n      ) {\n        return output as ToolMessage | Command;\n      }\n\n      return new ToolMessage({\n        name: tool.name,\n        content: typeof output === \"string\" ? output : JSON.stringify(output),\n        tool_call_id: call.id!,\n      });\n    } catch (e: unknown) {\n      /**\n       * If tool invocation fails due to input parsing error, throw a {@link ToolInvocationError}\n       */\n      if (e instanceof ToolInputParsingException) {\n        throw new ToolInvocationError(e, call);\n      }\n\n      /**\n       * throw the error if user prefers not to handle tool errors\n       */\n      if (!this.handleToolErrors) {\n        throw e;\n      }\n\n      if (isGraphInterrupt(e)) {\n        /**\n         * {@link NodeInterrupt} errors are a breakpoint to bring a human into the loop.\n         * As such, they are not recoverable by the agent and shouldn't be fed\n         * back. Instead, re-throw these errors even when `handleToolErrors = true`.\n         */\n        throw e;\n      }\n\n      /**\n       * If the signal is aborted, we want to bubble up the error to the invoke caller.\n       */\n      if (this.signal?.aborted) {\n        throw e;\n      }\n\n      /**\n       * if the user provides a function, call it with the error and tool call\n       * and return the result if it is a {@link ToolMessage}\n       */\n      if (typeof this.handleToolErrors === \"function\") {\n        const result = this.handleToolErrors(e, call);\n        if (result && isToolMessage(result)) {\n          return result;\n        }\n      } else if (this.handleToolErrors) {\n        return new ToolMessage({\n          name: call.name,\n          content: `${e}\\n Please fix your mistakes.`,\n          tool_call_id: call.id!,\n        });\n      }\n\n      /**\n       * If the user doesn't handle the error, throw it\n       */\n      throw e;\n    }\n  }\n\n  protected async run(\n    state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ): Promise<ContextSchema> {\n    let outputs: (ToolMessage | Command)[];\n\n    if (isSendInput(state)) {\n      outputs = [await this.runTool(state.lg_tool_call, config)];\n    } else {\n      let messages: BaseMessage[];\n      if (isBaseMessageArray(state)) {\n        messages = state;\n      } else if (isMessagesState(state)) {\n        messages = state.messages;\n      } else {\n        throw new Error(\n          \"ToolNode only accepts BaseMessage[] or { messages: BaseMessage[] } as input.\"\n        );\n      }\n\n      const toolMessageIds: Set<string> = new Set(\n        messages\n          .filter((msg) => msg.getType() === \"tool\")\n          .map((msg) => (msg as ToolMessage).tool_call_id)\n      );\n\n      let aiMessage: AIMessage | undefined;\n      for (let i = messages.length - 1; i >= 0; i -= 1) {\n        const message = messages[i];\n        if (message.getType() === \"ai\") {\n          aiMessage = message;\n          break;\n        }\n      }\n\n      if (aiMessage?.getType() !== \"ai\") {\n        throw new Error(\"ToolNode only accepts AIMessages as input.\");\n      }\n\n      outputs = await Promise.all(\n        aiMessage.tool_calls\n          ?.filter((call) => call.id == null || !toolMessageIds.has(call.id))\n          .map((call) => this.runTool(call, config)) ?? []\n      );\n    }\n\n    // Preserve existing behavior for non-command tool outputs for backwards compatibility\n    if (!outputs.some(isCommand)) {\n      return (Array.isArray(state)\n        ? outputs\n        : { messages: outputs }) as unknown as ContextSchema;\n    }\n\n    // Handle mixed Command and non-Command outputs\n    const combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[] = [];\n    let parentCommand: Command | null = null;\n\n    for (const output of outputs) {\n      if (isCommand(output)) {\n        if (\n          output.graph === Command.PARENT &&\n          Array.isArray(output.goto) &&\n          output.goto.every((send) => isSend(send))\n        ) {\n          if (parentCommand) {\n            (parentCommand.goto as Send[]).push(...(output.goto as Send[]));\n          } else {\n            parentCommand = new Command({\n              graph: Command.PARENT,\n              goto: output.goto,\n            });\n          }\n        } else {\n          combinedOutputs.push(output);\n        }\n      } else {\n        combinedOutputs.push(\n          Array.isArray(state) ? [output] : { messages: [output] }\n        );\n      }\n    }\n\n    if (parentCommand) {\n      combinedOutputs.push(parentCommand);\n    }\n\n    return combinedOutputs as unknown as ContextSchema;\n  }\n}\n\nexport function isSend(x: unknown): x is Send {\n  // eslint-disable-next-line no-instanceof/no-instanceof\n  return x instanceof Send;\n}\n"],"mappings":"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"}
+{"version":3,"file":"ToolNode.cjs","names":["input: unknown","isBaseMessage","RunnableCallable","tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[]","options?: ToolNodeOptions","call: ToolCall","config: RunnableConfig","tool","mergeAbortSignals","ToolMessage","e: unknown","ToolInputParsingException","ToolInvocationError","state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"]","outputs: (ToolMessage | Command)[]","messages: BaseMessage[]","toolMessageIds: Set<string>","aiMessage: AIMessage | undefined","AIMessage","isCommand","combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[]","parentCommand: Command | null","Command","x: unknown","Send"],"sources":["../../../src/agents/nodes/ToolNode.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable no-instanceof/no-instanceof */\nimport {\n  BaseMessage,\n  ToolMessage,\n  AIMessage,\n  isBaseMessage,\n  isToolMessage,\n} from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport {\n  DynamicTool,\n  StructuredToolInterface,\n  ToolInputParsingException,\n} from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  isCommand,\n  Command,\n  Send,\n  isGraphInterrupt,\n} from \"@langchain/langgraph\";\n\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport {\n  PreHookAnnotation,\n  AnyAnnotationRoot,\n  ToAnnotationRoot,\n} from \"../annotation.js\";\nimport { mergeAbortSignals } from \"./utils.js\";\nimport { ToolInvocationError } from \"../errors.js\";\n\nexport interface ToolNodeOptions {\n  /**\n   * The name of the tool node.\n   */\n  name?: string;\n  /**\n   * The tags to add to the tool call.\n   */\n  tags?: string[];\n  /**\n   * The abort signal to cancel the tool call.\n   */\n  signal?: AbortSignal;\n  /**\n   * Whether to throw the error immediately if the tool fails or handle it by the `onToolError` function or via ToolMessage.\n   *\n   * If `true` (default):\n   *   - a tool message with the error will be returned to the LLM\n   *\n   * If `false`:\n   *   - the error will be thrown immediately\n   *\n   * If a function is provided:\n   *   - returns a custom {@link ToolMessage} as result\n   *   - throws an error otherwise\n   *\n   * @default true\n   */\n  handleToolErrors?:\n    | boolean\n    | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n}\n\nconst isBaseMessageArray = (input: unknown): input is BaseMessage[] =>\n  Array.isArray(input) && input.every(isBaseMessage);\n\nconst isMessagesState = (\n  input: unknown\n): input is { messages: BaseMessage[] } =>\n  typeof input === \"object\" &&\n  input != null &&\n  \"messages\" in input &&\n  isBaseMessageArray(input.messages);\n\nconst isSendInput = (input: unknown): input is { lg_tool_call: ToolCall } =>\n  typeof input === \"object\" && input != null && \"lg_tool_call\" in input;\n\n/**\n * `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.\n * It works seamlessly with `createAgent`, offering advanced tool execution control, built\n * in parallelism, and error handling.\n *\n * @example\n * ```ts\n * import { ToolNode, tool, AIMessage } from \"langchain\";\n * import { z } from \"zod/v3\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n */\nexport class ToolNode<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = any,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = any\n> extends RunnableCallable<StateSchema, ContextSchema> {\n  tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n\n  trace = false;\n\n  signal?: AbortSignal;\n\n  handleToolErrors:\n    | boolean\n    | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined) = true;\n\n  constructor(\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[],\n    public options?: ToolNodeOptions\n  ) {\n    const { name, tags, handleToolErrors } = options ?? {};\n    super({\n      name,\n      tags,\n      func: (state, config) =>\n        this.run(\n          state as ToAnnotationRoot<StateSchema>[\"State\"] &\n            PreHookAnnotation[\"State\"],\n          config as RunnableConfig\n        ),\n    });\n    this.tools = tools;\n    this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;\n    this.signal = options?.signal;\n  }\n\n  protected async runTool(\n    call: ToolCall,\n    config: RunnableConfig\n  ): Promise<ToolMessage | Command> {\n    const tool = this.tools.find((tool) => tool.name === call.name);\n    try {\n      if (tool === undefined) {\n        throw new Error(`Tool \"${call.name}\" not found.`);\n      }\n\n      const output = await tool.invoke(\n        { ...call, type: \"tool_call\" },\n        {\n          ...config,\n          signal: mergeAbortSignals(this.signal, config.signal),\n        }\n      );\n\n      if (ToolMessage.isInstance(output) || isCommand(output)) {\n        return output as ToolMessage | Command;\n      }\n\n      return new ToolMessage({\n        name: tool.name,\n        content: typeof output === \"string\" ? output : JSON.stringify(output),\n        tool_call_id: call.id!,\n      });\n    } catch (e: unknown) {\n      /**\n       * If tool invocation fails due to input parsing error, throw a {@link ToolInvocationError}\n       */\n      if (e instanceof ToolInputParsingException) {\n        throw new ToolInvocationError(e, call);\n      }\n\n      /**\n       * throw the error if user prefers not to handle tool errors\n       */\n      if (!this.handleToolErrors) {\n        throw e;\n      }\n\n      if (isGraphInterrupt(e)) {\n        /**\n         * {@link NodeInterrupt} errors are a breakpoint to bring a human into the loop.\n         * As such, they are not recoverable by the agent and shouldn't be fed\n         * back. Instead, re-throw these errors even when `handleToolErrors = true`.\n         */\n        throw e;\n      }\n\n      /**\n       * If the signal is aborted, we want to bubble up the error to the invoke caller.\n       */\n      if (this.signal?.aborted) {\n        throw e;\n      }\n\n      /**\n       * if the user provides a function, call it with the error and tool call\n       * and return the result if it is a {@link ToolMessage}\n       */\n      if (typeof this.handleToolErrors === \"function\") {\n        const result = this.handleToolErrors(e, call);\n        if (result && isToolMessage(result)) {\n          return result;\n        }\n      } else if (this.handleToolErrors) {\n        return new ToolMessage({\n          name: call.name,\n          content: `${e}\\n Please fix your mistakes.`,\n          tool_call_id: call.id!,\n        });\n      }\n\n      /**\n       * If the user doesn't handle the error, throw it\n       */\n      throw e;\n    }\n  }\n\n  protected async run(\n    state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ): Promise<ContextSchema> {\n    let outputs: (ToolMessage | Command)[];\n\n    if (isSendInput(state)) {\n      outputs = [await this.runTool(state.lg_tool_call, config)];\n    } else {\n      let messages: BaseMessage[];\n      if (isBaseMessageArray(state)) {\n        messages = state;\n      } else if (isMessagesState(state)) {\n        messages = state.messages;\n      } else {\n        throw new Error(\n          \"ToolNode only accepts BaseMessage[] or { messages: BaseMessage[] } as input.\"\n        );\n      }\n\n      const toolMessageIds: Set<string> = new Set(\n        messages\n          .filter((msg) => msg.getType() === \"tool\")\n          .map((msg) => (msg as ToolMessage).tool_call_id)\n      );\n\n      let aiMessage: AIMessage | undefined;\n      for (let i = messages.length - 1; i >= 0; i -= 1) {\n        const message = messages[i];\n        if (AIMessage.isInstance(message)) {\n          aiMessage = message;\n          break;\n        }\n      }\n\n      if (!AIMessage.isInstance(aiMessage)) {\n        throw new Error(\"ToolNode only accepts AIMessages as input.\");\n      }\n\n      outputs = await Promise.all(\n        aiMessage.tool_calls\n          ?.filter((call) => call.id == null || !toolMessageIds.has(call.id))\n          .map((call) => this.runTool(call, config)) ?? []\n      );\n    }\n\n    // Preserve existing behavior for non-command tool outputs for backwards compatibility\n    if (!outputs.some(isCommand)) {\n      return (Array.isArray(state)\n        ? outputs\n        : { messages: outputs }) as unknown as ContextSchema;\n    }\n\n    // Handle mixed Command and non-Command outputs\n    const combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[] = [];\n    let parentCommand: Command | null = null;\n\n    for (const output of outputs) {\n      if (isCommand(output)) {\n        if (\n          output.graph === Command.PARENT &&\n          Array.isArray(output.goto) &&\n          output.goto.every((send) => isSend(send))\n        ) {\n          if (parentCommand) {\n            (parentCommand.goto as Send[]).push(...(output.goto as Send[]));\n          } else {\n            parentCommand = new Command({\n              graph: Command.PARENT,\n              goto: output.goto,\n            });\n          }\n        } else {\n          combinedOutputs.push(output);\n        }\n      } else {\n        combinedOutputs.push(\n          Array.isArray(state) ? [output] : { messages: [output] }\n        );\n      }\n    }\n\n    if (parentCommand) {\n      combinedOutputs.push(parentCommand);\n    }\n\n    return combinedOutputs as unknown as ContextSchema;\n  }\n}\n\nexport function isSend(x: unknown): x is Send {\n  return x instanceof Send;\n}\n"],"mappings":"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"}

package/dist/agents/nodes/ToolNode.d.cts

@@ -3,8 +3,8 @@ import { RunnableCallable } from "../RunnableCallable.cjs";
 import { InteropZodObject } from "@langchain/core/utils/types";
 import { Command } from "@langchain/langgraph";
 import { ToolMessage } from "@langchain/core/messages";
-import { RunnableConfig, RunnableToolLike } from "@langchain/core/runnables";
 import { ToolCall } from "@langchain/core/messages/tool";
+import { RunnableConfig, RunnableToolLike } from "@langchain/core/runnables";
 import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
 
 //#region src/agents/nodes/ToolNode.d.ts
@@ -46,7 +46,7 @@ interface ToolNodeOptions {
  * @example
  * ```ts
  * import { ToolNode, tool, AIMessage } from "langchain";
- * import { z } from "zod";
+ * import { z } from "zod/v3";
  *
  * const getWeather = tool((input) => {
  *   if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
@@ -82,7 +82,6 @@ interface ToolNodeOptions {
  * // { messages: ToolMessage[] }
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare class ToolNode<StateSchema extends AnyAnnotationRoot | InteropZodObject = any, ContextSchema extends AnyAnnotationRoot | InteropZodObject = any> extends RunnableCallable<StateSchema, ContextSchema> {
   options?: ToolNodeOptions | undefined;
   tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];

package/dist/agents/nodes/ToolNode.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolNode.d.cts","names":["ToolMessage","RunnableConfig","RunnableToolLike","DynamicTool","StructuredToolInterface","ToolCall","InteropZodObject","Command","Send","RunnableCallable","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","ToolNodeOptions","AbortSignal","ToolNode","StateSchema","ContextSchema","Promise","isSend"],"sources":["../../../src/agents/nodes/ToolNode.d.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\nimport { ToolMessage } from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { InteropZodObject } from \"@langchain/core/utils/types\";\nimport { Command, Send } from \"@langchain/langgraph\";\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport { PreHookAnnotation, AnyAnnotationRoot, ToAnnotationRoot } from \"../annotation.js\";\nexport interface ToolNodeOptions {\n    /**\n     * The name of the tool node.\n     */\n    name?: string;\n    /**\n     * The tags to add to the tool call.\n     */\n    tags?: string[];\n    /**\n     * The abort signal to cancel the tool call.\n     */\n    signal?: AbortSignal;\n    /**\n     * Whether to throw the error immediately if the tool fails or handle it by the `onToolError` function or via ToolMessage.\n     *\n     * If `true` (default):\n     *   - a tool message with the error will be returned to the LLM\n     *\n     * If `false`:\n     *   - the error will be thrown immediately\n     *\n     * If a function is provided:\n     *   - returns a custom {@link ToolMessage} as result\n     *   - throws an error otherwise\n     *\n     * @default true\n     */\n    handleToolErrors?: boolean | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n}\n/**\n * `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.\n * It works seamlessly with `createAgent`, offering advanced tool execution control, built\n * in parallelism, and error handling.\n *\n * @example\n * ```ts\n * import { ToolNode, tool, AIMessage } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare class ToolNode<StateSchema extends AnyAnnotationRoot | InteropZodObject = any, ContextSchema extends AnyAnnotationRoot | InteropZodObject = any> extends RunnableCallable<StateSchema, ContextSchema> {\n    options?: ToolNodeOptions | undefined;\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n    trace: boolean;\n    signal?: AbortSignal;\n    handleToolErrors: boolean | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n    constructor(tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[], options?: ToolNodeOptions | undefined);\n    protected runTool(call: ToolCall, config: RunnableConfig): Promise<ToolMessage | Command>;\n    protected run(state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], config: RunnableConfig): Promise<ContextSchema>;\n}\nexport declare function isSend(x: unknown): x is Send;\n"],"mappings":";;;;;;;;;;UASiBa,eAAAA;EAAAA;;;EAYO,IAgBqCR,CAAAA,EAAAA,MAAAA;EAAQ;AAAgB;AA+CrF;EAA6B,IAAA,CAAA,EAAA,MAAA,EAAA;EAAA;;;EAAwG,MAAGC,CAAAA,EA/D3HQ,WA+D2HR;EAAgB;;;;;;;;;;;;;;;EAO5F,gBAAWN,CAAAA,EAAAA,OAAAA,GAAAA,CAAAA,CAAAA,KAAAA,EAAAA,OAAAA,EAAAA,QAAAA,EAtDVK,QAsDUL,EAAAA,GAtDGA,WAsDHA,GAAAA,SAAAA,CAAAA;;;;;;;;;;AAPiH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAnKe,6BAA6BJ,oBAAoBL,8CAA8CK,oBAAoBL,gCAAgCG,iBAAiBO,aAAaC;YACxLJ;UACFT,0BAA0BD,cAAcD;;WAEvCY;0DAC+CT,aAAaL;sBACjDI,0BAA0BD,cAAcD,+BAA+BW;0BACnER,kBAAkBJ,iBAAiBiB,QAAQlB,cAAcO;uBAC5DK,iBAAiBI,wBAAwBN,oCAAoCT,iBAAiBiB,QAAQD"}
+{"version":3,"file":"ToolNode.d.cts","names":["ToolMessage","RunnableConfig","RunnableToolLike","DynamicTool","StructuredToolInterface","ToolCall","InteropZodObject","Command","Send","RunnableCallable","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","ToolNodeOptions","AbortSignal","ToolNode","StateSchema","ContextSchema","Promise","isSend"],"sources":["../../../src/agents/nodes/ToolNode.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable no-instanceof/no-instanceof */\nimport { ToolMessage } from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { InteropZodObject } from \"@langchain/core/utils/types\";\nimport { Command, Send } from \"@langchain/langgraph\";\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport { PreHookAnnotation, AnyAnnotationRoot, ToAnnotationRoot } from \"../annotation.js\";\nexport interface ToolNodeOptions {\n    /**\n     * The name of the tool node.\n     */\n    name?: string;\n    /**\n     * The tags to add to the tool call.\n     */\n    tags?: string[];\n    /**\n     * The abort signal to cancel the tool call.\n     */\n    signal?: AbortSignal;\n    /**\n     * Whether to throw the error immediately if the tool fails or handle it by the `onToolError` function or via ToolMessage.\n     *\n     * If `true` (default):\n     *   - a tool message with the error will be returned to the LLM\n     *\n     * If `false`:\n     *   - the error will be thrown immediately\n     *\n     * If a function is provided:\n     *   - returns a custom {@link ToolMessage} as result\n     *   - throws an error otherwise\n     *\n     * @default true\n     */\n    handleToolErrors?: boolean | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n}\n/**\n * `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.\n * It works seamlessly with `createAgent`, offering advanced tool execution control, built\n * in parallelism, and error handling.\n *\n * @example\n * ```ts\n * import { ToolNode, tool, AIMessage } from \"langchain\";\n * import { z } from \"zod/v3\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n */\nexport declare class ToolNode<StateSchema extends AnyAnnotationRoot | InteropZodObject = any, ContextSchema extends AnyAnnotationRoot | InteropZodObject = any> extends RunnableCallable<StateSchema, ContextSchema> {\n    options?: ToolNodeOptions | undefined;\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n    trace: boolean;\n    signal?: AbortSignal;\n    handleToolErrors: boolean | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n    constructor(tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[], options?: ToolNodeOptions | undefined);\n    protected runTool(call: ToolCall, config: RunnableConfig): Promise<ToolMessage | Command>;\n    protected run(state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], config: RunnableConfig): Promise<ContextSchema>;\n}\nexport declare function isSend(x: unknown): x is Send;\n"],"mappings":";;;;;;;;;;AAUiBa,UAAAA,eAAAA,CAAe;EAAA;;;EA4BqC,IAAKb,CAAAA,EAAAA,MAAAA;EAAW;AA8CrF;;EAA6B,IAAqBW,CAAAA,EAAAA,MAAAA,EAAAA;EAAiB;;;EAAqF,MAAiCK,CAAAA,EA9D5KF,WA8D4KE;EAAW;;;;;;;;;;;;;;;EAOlH,gBAAGT,CAAAA,EAAAA,OAAAA,GAAAA,CAAAA,CAAAA,KAAAA,EAAAA,OAAAA,EAAAA,QAAAA,EArDxBF,QAqDwBE,EAAAA,GArDXP,WAqDWO,GAAAA,SAAAA,CAAAA;;;;;;;;;AAPmG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAnKQ,6BAA6BJ,oBAAoBL,8CAA8CK,oBAAoBL,gCAAgCG,iBAAiBO,aAAaC;YACxLJ;UACFT,0BAA0BD,cAAcD;;WAEvCY;0DAC+CT,aAAaL;sBACjDI,0BAA0BD,cAAcD,+BAA+BW;0BACnER,kBAAkBJ,iBAAiBiB,QAAQlB,cAAcO;uBAC5DK,iBAAiBI,wBAAwBN,oCAAoCT,iBAAiBiB,QAAQD"}

package/dist/agents/nodes/ToolNode.d.ts

@@ -46,7 +46,7 @@ interface ToolNodeOptions {
  * @example
  * ```ts
  * import { ToolNode, tool, AIMessage } from "langchain";
- * import { z } from "zod";
+ * import { z } from "zod/v3";
  *
  * const getWeather = tool((input) => {
  *   if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
@@ -82,7 +82,6 @@ interface ToolNodeOptions {
  * // { messages: ToolMessage[] }
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare class ToolNode<StateSchema extends AnyAnnotationRoot | InteropZodObject = any, ContextSchema extends AnyAnnotationRoot | InteropZodObject = any> extends RunnableCallable<StateSchema, ContextSchema> {
   options?: ToolNodeOptions | undefined;
   tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];

package/dist/agents/nodes/ToolNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolNode.d.ts","names":["ToolMessage","RunnableConfig","RunnableToolLike","DynamicTool","StructuredToolInterface","ToolCall","InteropZodObject","Command","Send","RunnableCallable","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","ToolNodeOptions","AbortSignal","ToolNode","StateSchema","ContextSchema","Promise","isSend"],"sources":["../../../src/agents/nodes/ToolNode.d.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\nimport { ToolMessage } from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { InteropZodObject } from \"@langchain/core/utils/types\";\nimport { Command, Send } from \"@langchain/langgraph\";\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport { PreHookAnnotation, AnyAnnotationRoot, ToAnnotationRoot } from \"../annotation.js\";\nexport interface ToolNodeOptions {\n    /**\n     * The name of the tool node.\n     */\n    name?: string;\n    /**\n     * The tags to add to the tool call.\n     */\n    tags?: string[];\n    /**\n     * The abort signal to cancel the tool call.\n     */\n    signal?: AbortSignal;\n    /**\n     * Whether to throw the error immediately if the tool fails or handle it by the `onToolError` function or via ToolMessage.\n     *\n     * If `true` (default):\n     *   - a tool message with the error will be returned to the LLM\n     *\n     * If `false`:\n     *   - the error will be thrown immediately\n     *\n     * If a function is provided:\n     *   - returns a custom {@link ToolMessage} as result\n     *   - throws an error otherwise\n     *\n     * @default true\n     */\n    handleToolErrors?: boolean | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n}\n/**\n * `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.\n * It works seamlessly with `createAgent`, offering advanced tool execution control, built\n * in parallelism, and error handling.\n *\n * @example\n * ```ts\n * import { ToolNode, tool, AIMessage } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare class ToolNode<StateSchema extends AnyAnnotationRoot | InteropZodObject = any, ContextSchema extends AnyAnnotationRoot | InteropZodObject = any> extends RunnableCallable<StateSchema, ContextSchema> {\n    options?: ToolNodeOptions | undefined;\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n    trace: boolean;\n    signal?: AbortSignal;\n    handleToolErrors: boolean | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n    constructor(tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[], options?: ToolNodeOptions | undefined);\n    protected runTool(call: ToolCall, config: RunnableConfig): Promise<ToolMessage | Command>;\n    protected run(state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], config: RunnableConfig): Promise<ContextSchema>;\n}\nexport declare function isSend(x: unknown): x is Send;\n"],"mappings":";;;;;;;;;;UASiBa,eAAAA;EAAAA;;;EAYO,IAgBqCR,CAAAA,EAAAA,MAAAA;EAAQ;AAAgB;AA+CrF;EAA6B,IAAA,CAAA,EAAA,MAAA,EAAA;EAAA;;;EAAwG,MAAGC,CAAAA,EA/D3HQ,WA+D2HR;EAAgB;;;;;;;;;;;;;;;EAO5F,gBAAWN,CAAAA,EAAAA,OAAAA,GAAAA,CAAAA,CAAAA,KAAAA,EAAAA,OAAAA,EAAAA,QAAAA,EAtDVK,QAsDUL,EAAAA,GAtDGA,WAsDHA,GAAAA,SAAAA,CAAAA;;;;;;;;;;AAPiH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAnKe,6BAA6BJ,oBAAoBL,8CAA8CK,oBAAoBL,gCAAgCG,iBAAiBO,aAAaC;YACxLJ;UACFT,0BAA0BD,cAAcD;;WAEvCY;0DAC+CT,aAAaL;sBACjDI,0BAA0BD,cAAcD,+BAA+BW;0BACnER,kBAAkBJ,iBAAiBiB,QAAQlB,cAAcO;uBAC5DK,iBAAiBI,wBAAwBN,oCAAoCT,iBAAiBiB,QAAQD"}
+{"version":3,"file":"ToolNode.d.ts","names":["ToolMessage","RunnableConfig","RunnableToolLike","DynamicTool","StructuredToolInterface","ToolCall","InteropZodObject","Command","Send","RunnableCallable","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","ToolNodeOptions","AbortSignal","ToolNode","StateSchema","ContextSchema","Promise","isSend"],"sources":["../../../src/agents/nodes/ToolNode.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable no-instanceof/no-instanceof */\nimport { ToolMessage } from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { InteropZodObject } from \"@langchain/core/utils/types\";\nimport { Command, Send } from \"@langchain/langgraph\";\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport { PreHookAnnotation, AnyAnnotationRoot, ToAnnotationRoot } from \"../annotation.js\";\nexport interface ToolNodeOptions {\n    /**\n     * The name of the tool node.\n     */\n    name?: string;\n    /**\n     * The tags to add to the tool call.\n     */\n    tags?: string[];\n    /**\n     * The abort signal to cancel the tool call.\n     */\n    signal?: AbortSignal;\n    /**\n     * Whether to throw the error immediately if the tool fails or handle it by the `onToolError` function or via ToolMessage.\n     *\n     * If `true` (default):\n     *   - a tool message with the error will be returned to the LLM\n     *\n     * If `false`:\n     *   - the error will be thrown immediately\n     *\n     * If a function is provided:\n     *   - returns a custom {@link ToolMessage} as result\n     *   - throws an error otherwise\n     *\n     * @default true\n     */\n    handleToolErrors?: boolean | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n}\n/**\n * `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.\n * It works seamlessly with `createAgent`, offering advanced tool execution control, built\n * in parallelism, and error handling.\n *\n * @example\n * ```ts\n * import { ToolNode, tool, AIMessage } from \"langchain\";\n * import { z } from \"zod/v3\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n */\nexport declare class ToolNode<StateSchema extends AnyAnnotationRoot | InteropZodObject = any, ContextSchema extends AnyAnnotationRoot | InteropZodObject = any> extends RunnableCallable<StateSchema, ContextSchema> {\n    options?: ToolNodeOptions | undefined;\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n    trace: boolean;\n    signal?: AbortSignal;\n    handleToolErrors: boolean | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n    constructor(tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[], options?: ToolNodeOptions | undefined);\n    protected runTool(call: ToolCall, config: RunnableConfig): Promise<ToolMessage | Command>;\n    protected run(state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], config: RunnableConfig): Promise<ContextSchema>;\n}\nexport declare function isSend(x: unknown): x is Send;\n"],"mappings":";;;;;;;;;;AAUiBa,UAAAA,eAAAA,CAAe;EAAA;;;EA4BqC,IAAKb,CAAAA,EAAAA,MAAAA;EAAW;AA8CrF;;EAA6B,IAAqBW,CAAAA,EAAAA,MAAAA,EAAAA;EAAiB;;;EAAqF,MAAiCK,CAAAA,EA9D5KF,WA8D4KE;EAAW;;;;;;;;;;;;;;;EAOlH,gBAAGT,CAAAA,EAAAA,OAAAA,GAAAA,CAAAA,CAAAA,KAAAA,EAAAA,OAAAA,EAAAA,QAAAA,EArDxBF,QAqDwBE,EAAAA,GArDXP,WAqDWO,GAAAA,SAAAA,CAAAA;;;;;;;;;AAPmG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAnKQ,6BAA6BJ,oBAAoBL,8CAA8CK,oBAAoBL,gCAAgCG,iBAAiBO,aAAaC;YACxLJ;UACFT,0BAA0BD,cAAcD;;WAEvCY;0DAC+CT,aAAaL;sBACjDI,0BAA0BD,cAAcD,+BAA+BW;0BACnER,kBAAkBJ,iBAAiBiB,QAAQlB,cAAcO;uBAC5DK,iBAAiBI,wBAAwBN,oCAAoCT,iBAAiBiB,QAAQD"}

package/dist/agents/nodes/ToolNode.js

@@ -1,7 +1,7 @@
 import { ToolInvocationError } from "../errors.js";
 import { RunnableCallable } from "../RunnableCallable.js";
 import { mergeAbortSignals } from "./utils.js";
-import { ToolMessage, isBaseMessage, isToolMessage } from "@langchain/core/messages";
+import { AIMessage, ToolMessage, isBaseMessage, isToolMessage } from "@langchain/core/messages";
 import { ToolInputParsingException } from "@langchain/core/tools";
 import { Command, Send, isCommand, isGraphInterrupt } from "@langchain/langgraph";
 
@@ -17,7 +17,7 @@ const isSendInput = (input) => typeof input === "object" && input != null && "lg
 * @example
 * ```ts
 * import { ToolNode, tool, AIMessage } from "langchain";
-* import { z } from "zod";
+* import { z } from "zod/v3";
 *
 * const getWeather = tool((input) => {
 *   if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
@@ -81,7 +81,7 @@ var ToolNode = class extends RunnableCallable {
 				...config,
 				signal: mergeAbortSignals(this.signal, config.signal)
 			});
-			if (isBaseMessage(output) && output.getType() === "tool" || isCommand(output)) return output;
+			if (ToolMessage.isInstance(output) || isCommand(output)) return output;
 			return new ToolMessage({
 				name: tool.name,
 				content: typeof output === "string" ? output : JSON.stringify(output),
@@ -137,12 +137,12 @@ var ToolNode = class extends RunnableCallable {
 			let aiMessage;
 			for (let i = messages.length - 1; i >= 0; i -= 1) {
 				const message = messages[i];
-				if (message.getType() === "ai") {
+				if (AIMessage.isInstance(message)) {
 					aiMessage = message;
 					break;
 				}
 			}
-			if (aiMessage?.getType() !== "ai") throw new Error("ToolNode only accepts AIMessages as input.");
+			if (!AIMessage.isInstance(aiMessage)) throw new Error("ToolNode only accepts AIMessages as input.");
 			outputs = await Promise.all(aiMessage.tool_calls?.filter((call) => call.id == null || !toolMessageIds.has(call.id)).map((call) => this.runTool(call, config)) ?? []);
 		}
 		if (!outputs.some(isCommand)) return Array.isArray(state) ? outputs : { messages: outputs };

package/dist/agents/nodes/ToolNode.js.map

@@ -1 +1 @@
-{"version":3,"file":"ToolNode.js","names":["input: unknown","tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[]","options?: ToolNodeOptions","call: ToolCall","config: RunnableConfig","tool","e: unknown","state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"]","outputs: (ToolMessage | Command)[]","messages: BaseMessage[]","toolMessageIds: Set<string>","aiMessage: AIMessage | undefined","combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[]","parentCommand: Command | null","x: unknown"],"sources":["../../../src/agents/nodes/ToolNode.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\nimport {\n  BaseMessage,\n  ToolMessage,\n  AIMessage,\n  isBaseMessage,\n  isToolMessage,\n} from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport {\n  DynamicTool,\n  StructuredToolInterface,\n  ToolInputParsingException,\n} from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  isCommand,\n  Command,\n  Send,\n  isGraphInterrupt,\n  type NodeInterrupt,\n} from \"@langchain/langgraph\";\n\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport {\n  PreHookAnnotation,\n  AnyAnnotationRoot,\n  ToAnnotationRoot,\n} from \"../annotation.js\";\nimport { mergeAbortSignals } from \"./utils.js\";\nimport { ToolInvocationError } from \"../errors.js\";\n\nexport interface ToolNodeOptions {\n  /**\n   * The name of the tool node.\n   */\n  name?: string;\n  /**\n   * The tags to add to the tool call.\n   */\n  tags?: string[];\n  /**\n   * The abort signal to cancel the tool call.\n   */\n  signal?: AbortSignal;\n  /**\n   * Whether to throw the error immediately if the tool fails or handle it by the `onToolError` function or via ToolMessage.\n   *\n   * If `true` (default):\n   *   - a tool message with the error will be returned to the LLM\n   *\n   * If `false`:\n   *   - the error will be thrown immediately\n   *\n   * If a function is provided:\n   *   - returns a custom {@link ToolMessage} as result\n   *   - throws an error otherwise\n   *\n   * @default true\n   */\n  handleToolErrors?:\n    | boolean\n    | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n}\n\nconst isBaseMessageArray = (input: unknown): input is BaseMessage[] =>\n  Array.isArray(input) && input.every(isBaseMessage);\n\nconst isMessagesState = (\n  input: unknown\n): input is { messages: BaseMessage[] } =>\n  typeof input === \"object\" &&\n  input != null &&\n  \"messages\" in input &&\n  isBaseMessageArray(input.messages);\n\nconst isSendInput = (input: unknown): input is { lg_tool_call: ToolCall } =>\n  typeof input === \"object\" && input != null && \"lg_tool_call\" in input;\n\n/**\n * `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.\n * It works seamlessly with `createAgent`, offering advanced tool execution control, built\n * in parallelism, and error handling.\n *\n * @example\n * ```ts\n * import { ToolNode, tool, AIMessage } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class ToolNode<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = any,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = any\n> extends RunnableCallable<StateSchema, ContextSchema> {\n  tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n\n  trace = false;\n\n  signal?: AbortSignal;\n\n  handleToolErrors:\n    | boolean\n    | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined) = true;\n\n  constructor(\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[],\n    public options?: ToolNodeOptions\n  ) {\n    const { name, tags, handleToolErrors } = options ?? {};\n    super({\n      name,\n      tags,\n      func: (state, config) =>\n        this.run(\n          state as ToAnnotationRoot<StateSchema>[\"State\"] &\n            PreHookAnnotation[\"State\"],\n          config as RunnableConfig\n        ),\n    });\n    this.tools = tools;\n    this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;\n    this.signal = options?.signal;\n  }\n\n  protected async runTool(\n    call: ToolCall,\n    config: RunnableConfig\n  ): Promise<ToolMessage | Command> {\n    const tool = this.tools.find((tool) => tool.name === call.name);\n    try {\n      if (tool === undefined) {\n        throw new Error(`Tool \"${call.name}\" not found.`);\n      }\n\n      const output = await tool.invoke(\n        { ...call, type: \"tool_call\" },\n        {\n          ...config,\n          signal: mergeAbortSignals(this.signal, config.signal),\n        }\n      );\n\n      if (\n        (isBaseMessage(output) && output.getType() === \"tool\") ||\n        isCommand(output)\n      ) {\n        return output as ToolMessage | Command;\n      }\n\n      return new ToolMessage({\n        name: tool.name,\n        content: typeof output === \"string\" ? output : JSON.stringify(output),\n        tool_call_id: call.id!,\n      });\n    } catch (e: unknown) {\n      /**\n       * If tool invocation fails due to input parsing error, throw a {@link ToolInvocationError}\n       */\n      if (e instanceof ToolInputParsingException) {\n        throw new ToolInvocationError(e, call);\n      }\n\n      /**\n       * throw the error if user prefers not to handle tool errors\n       */\n      if (!this.handleToolErrors) {\n        throw e;\n      }\n\n      if (isGraphInterrupt(e)) {\n        /**\n         * {@link NodeInterrupt} errors are a breakpoint to bring a human into the loop.\n         * As such, they are not recoverable by the agent and shouldn't be fed\n         * back. Instead, re-throw these errors even when `handleToolErrors = true`.\n         */\n        throw e;\n      }\n\n      /**\n       * If the signal is aborted, we want to bubble up the error to the invoke caller.\n       */\n      if (this.signal?.aborted) {\n        throw e;\n      }\n\n      /**\n       * if the user provides a function, call it with the error and tool call\n       * and return the result if it is a {@link ToolMessage}\n       */\n      if (typeof this.handleToolErrors === \"function\") {\n        const result = this.handleToolErrors(e, call);\n        if (result && isToolMessage(result)) {\n          return result;\n        }\n      } else if (this.handleToolErrors) {\n        return new ToolMessage({\n          name: call.name,\n          content: `${e}\\n Please fix your mistakes.`,\n          tool_call_id: call.id!,\n        });\n      }\n\n      /**\n       * If the user doesn't handle the error, throw it\n       */\n      throw e;\n    }\n  }\n\n  protected async run(\n    state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ): Promise<ContextSchema> {\n    let outputs: (ToolMessage | Command)[];\n\n    if (isSendInput(state)) {\n      outputs = [await this.runTool(state.lg_tool_call, config)];\n    } else {\n      let messages: BaseMessage[];\n      if (isBaseMessageArray(state)) {\n        messages = state;\n      } else if (isMessagesState(state)) {\n        messages = state.messages;\n      } else {\n        throw new Error(\n          \"ToolNode only accepts BaseMessage[] or { messages: BaseMessage[] } as input.\"\n        );\n      }\n\n      const toolMessageIds: Set<string> = new Set(\n        messages\n          .filter((msg) => msg.getType() === \"tool\")\n          .map((msg) => (msg as ToolMessage).tool_call_id)\n      );\n\n      let aiMessage: AIMessage | undefined;\n      for (let i = messages.length - 1; i >= 0; i -= 1) {\n        const message = messages[i];\n        if (message.getType() === \"ai\") {\n          aiMessage = message;\n          break;\n        }\n      }\n\n      if (aiMessage?.getType() !== \"ai\") {\n        throw new Error(\"ToolNode only accepts AIMessages as input.\");\n      }\n\n      outputs = await Promise.all(\n        aiMessage.tool_calls\n          ?.filter((call) => call.id == null || !toolMessageIds.has(call.id))\n          .map((call) => this.runTool(call, config)) ?? []\n      );\n    }\n\n    // Preserve existing behavior for non-command tool outputs for backwards compatibility\n    if (!outputs.some(isCommand)) {\n      return (Array.isArray(state)\n        ? outputs\n        : { messages: outputs }) as unknown as ContextSchema;\n    }\n\n    // Handle mixed Command and non-Command outputs\n    const combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[] = [];\n    let parentCommand: Command | null = null;\n\n    for (const output of outputs) {\n      if (isCommand(output)) {\n        if (\n          output.graph === Command.PARENT &&\n          Array.isArray(output.goto) &&\n          output.goto.every((send) => isSend(send))\n        ) {\n          if (parentCommand) {\n            (parentCommand.goto as Send[]).push(...(output.goto as Send[]));\n          } else {\n            parentCommand = new Command({\n              graph: Command.PARENT,\n              goto: output.goto,\n            });\n          }\n        } else {\n          combinedOutputs.push(output);\n        }\n      } else {\n        combinedOutputs.push(\n          Array.isArray(state) ? [output] : { messages: [output] }\n        );\n      }\n    }\n\n    if (parentCommand) {\n      combinedOutputs.push(parentCommand);\n    }\n\n    return combinedOutputs as unknown as ContextSchema;\n  }\n}\n\nexport function isSend(x: unknown): x is Send {\n  // eslint-disable-next-line no-instanceof/no-instanceof\n  return x instanceof Send;\n}\n"],"mappings":"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"}
+{"version":3,"file":"ToolNode.js","names":["input: unknown","tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[]","options?: ToolNodeOptions","call: ToolCall","config: RunnableConfig","tool","e: unknown","state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"]","outputs: (ToolMessage | Command)[]","messages: BaseMessage[]","toolMessageIds: Set<string>","aiMessage: AIMessage | undefined","combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[]","parentCommand: Command | null","x: unknown"],"sources":["../../../src/agents/nodes/ToolNode.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable no-instanceof/no-instanceof */\nimport {\n  BaseMessage,\n  ToolMessage,\n  AIMessage,\n  isBaseMessage,\n  isToolMessage,\n} from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport {\n  DynamicTool,\n  StructuredToolInterface,\n  ToolInputParsingException,\n} from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  isCommand,\n  Command,\n  Send,\n  isGraphInterrupt,\n} from \"@langchain/langgraph\";\n\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport {\n  PreHookAnnotation,\n  AnyAnnotationRoot,\n  ToAnnotationRoot,\n} from \"../annotation.js\";\nimport { mergeAbortSignals } from \"./utils.js\";\nimport { ToolInvocationError } from \"../errors.js\";\n\nexport interface ToolNodeOptions {\n  /**\n   * The name of the tool node.\n   */\n  name?: string;\n  /**\n   * The tags to add to the tool call.\n   */\n  tags?: string[];\n  /**\n   * The abort signal to cancel the tool call.\n   */\n  signal?: AbortSignal;\n  /**\n   * Whether to throw the error immediately if the tool fails or handle it by the `onToolError` function or via ToolMessage.\n   *\n   * If `true` (default):\n   *   - a tool message with the error will be returned to the LLM\n   *\n   * If `false`:\n   *   - the error will be thrown immediately\n   *\n   * If a function is provided:\n   *   - returns a custom {@link ToolMessage} as result\n   *   - throws an error otherwise\n   *\n   * @default true\n   */\n  handleToolErrors?:\n    | boolean\n    | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n}\n\nconst isBaseMessageArray = (input: unknown): input is BaseMessage[] =>\n  Array.isArray(input) && input.every(isBaseMessage);\n\nconst isMessagesState = (\n  input: unknown\n): input is { messages: BaseMessage[] } =>\n  typeof input === \"object\" &&\n  input != null &&\n  \"messages\" in input &&\n  isBaseMessageArray(input.messages);\n\nconst isSendInput = (input: unknown): input is { lg_tool_call: ToolCall } =>\n  typeof input === \"object\" && input != null && \"lg_tool_call\" in input;\n\n/**\n * `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.\n * It works seamlessly with `createAgent`, offering advanced tool execution control, built\n * in parallelism, and error handling.\n *\n * @example\n * ```ts\n * import { ToolNode, tool, AIMessage } from \"langchain\";\n * import { z } from \"zod/v3\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n */\nexport class ToolNode<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = any,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = any\n> extends RunnableCallable<StateSchema, ContextSchema> {\n  tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n\n  trace = false;\n\n  signal?: AbortSignal;\n\n  handleToolErrors:\n    | boolean\n    | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined) = true;\n\n  constructor(\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[],\n    public options?: ToolNodeOptions\n  ) {\n    const { name, tags, handleToolErrors } = options ?? {};\n    super({\n      name,\n      tags,\n      func: (state, config) =>\n        this.run(\n          state as ToAnnotationRoot<StateSchema>[\"State\"] &\n            PreHookAnnotation[\"State\"],\n          config as RunnableConfig\n        ),\n    });\n    this.tools = tools;\n    this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;\n    this.signal = options?.signal;\n  }\n\n  protected async runTool(\n    call: ToolCall,\n    config: RunnableConfig\n  ): Promise<ToolMessage | Command> {\n    const tool = this.tools.find((tool) => tool.name === call.name);\n    try {\n      if (tool === undefined) {\n        throw new Error(`Tool \"${call.name}\" not found.`);\n      }\n\n      const output = await tool.invoke(\n        { ...call, type: \"tool_call\" },\n        {\n          ...config,\n          signal: mergeAbortSignals(this.signal, config.signal),\n        }\n      );\n\n      if (ToolMessage.isInstance(output) || isCommand(output)) {\n        return output as ToolMessage | Command;\n      }\n\n      return new ToolMessage({\n        name: tool.name,\n        content: typeof output === \"string\" ? output : JSON.stringify(output),\n        tool_call_id: call.id!,\n      });\n    } catch (e: unknown) {\n      /**\n       * If tool invocation fails due to input parsing error, throw a {@link ToolInvocationError}\n       */\n      if (e instanceof ToolInputParsingException) {\n        throw new ToolInvocationError(e, call);\n      }\n\n      /**\n       * throw the error if user prefers not to handle tool errors\n       */\n      if (!this.handleToolErrors) {\n        throw e;\n      }\n\n      if (isGraphInterrupt(e)) {\n        /**\n         * {@link NodeInterrupt} errors are a breakpoint to bring a human into the loop.\n         * As such, they are not recoverable by the agent and shouldn't be fed\n         * back. Instead, re-throw these errors even when `handleToolErrors = true`.\n         */\n        throw e;\n      }\n\n      /**\n       * If the signal is aborted, we want to bubble up the error to the invoke caller.\n       */\n      if (this.signal?.aborted) {\n        throw e;\n      }\n\n      /**\n       * if the user provides a function, call it with the error and tool call\n       * and return the result if it is a {@link ToolMessage}\n       */\n      if (typeof this.handleToolErrors === \"function\") {\n        const result = this.handleToolErrors(e, call);\n        if (result && isToolMessage(result)) {\n          return result;\n        }\n      } else if (this.handleToolErrors) {\n        return new ToolMessage({\n          name: call.name,\n          content: `${e}\\n Please fix your mistakes.`,\n          tool_call_id: call.id!,\n        });\n      }\n\n      /**\n       * If the user doesn't handle the error, throw it\n       */\n      throw e;\n    }\n  }\n\n  protected async run(\n    state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ): Promise<ContextSchema> {\n    let outputs: (ToolMessage | Command)[];\n\n    if (isSendInput(state)) {\n      outputs = [await this.runTool(state.lg_tool_call, config)];\n    } else {\n      let messages: BaseMessage[];\n      if (isBaseMessageArray(state)) {\n        messages = state;\n      } else if (isMessagesState(state)) {\n        messages = state.messages;\n      } else {\n        throw new Error(\n          \"ToolNode only accepts BaseMessage[] or { messages: BaseMessage[] } as input.\"\n        );\n      }\n\n      const toolMessageIds: Set<string> = new Set(\n        messages\n          .filter((msg) => msg.getType() === \"tool\")\n          .map((msg) => (msg as ToolMessage).tool_call_id)\n      );\n\n      let aiMessage: AIMessage | undefined;\n      for (let i = messages.length - 1; i >= 0; i -= 1) {\n        const message = messages[i];\n        if (AIMessage.isInstance(message)) {\n          aiMessage = message;\n          break;\n        }\n      }\n\n      if (!AIMessage.isInstance(aiMessage)) {\n        throw new Error(\"ToolNode only accepts AIMessages as input.\");\n      }\n\n      outputs = await Promise.all(\n        aiMessage.tool_calls\n          ?.filter((call) => call.id == null || !toolMessageIds.has(call.id))\n          .map((call) => this.runTool(call, config)) ?? []\n      );\n    }\n\n    // Preserve existing behavior for non-command tool outputs for backwards compatibility\n    if (!outputs.some(isCommand)) {\n      return (Array.isArray(state)\n        ? outputs\n        : { messages: outputs }) as unknown as ContextSchema;\n    }\n\n    // Handle mixed Command and non-Command outputs\n    const combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[] = [];\n    let parentCommand: Command | null = null;\n\n    for (const output of outputs) {\n      if (isCommand(output)) {\n        if (\n          output.graph === Command.PARENT &&\n          Array.isArray(output.goto) &&\n          output.goto.every((send) => isSend(send))\n        ) {\n          if (parentCommand) {\n            (parentCommand.goto as Send[]).push(...(output.goto as Send[]));\n          } else {\n            parentCommand = new Command({\n              graph: Command.PARENT,\n              goto: output.goto,\n            });\n          }\n        } else {\n          combinedOutputs.push(output);\n        }\n      } else {\n        combinedOutputs.push(\n          Array.isArray(state) ? [output] : { messages: [output] }\n        );\n      }\n    }\n\n    if (parentCommand) {\n      combinedOutputs.push(parentCommand);\n    }\n\n    return combinedOutputs as unknown as ContextSchema;\n  }\n}\n\nexport function isSend(x: unknown): x is Send {\n  return x instanceof Send;\n}\n"],"mappings":"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"}

package/dist/agents/responses.cjs

@@ -1,5 +1,6 @@
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_errors = require('./errors.cjs');
+const require_model = require('./model.cjs');
 const __langchain_core_utils_types = require_rolldown_runtime.__toESM(require("@langchain/core/utils/types"));
 const __langchain_core_utils_json_schema = require_rolldown_runtime.__toESM(require("@langchain/core/utils/json_schema"));
 
@@ -23,13 +24,13 @@ var ToolStrategy = class ToolStrategy {
 	get name() {
 		return this.tool.function.name;
 	}
-	static fromSchema(schema, options, outputOptions) {
+	static fromSchema(schema, outputOptions) {
 		/**
 		* It is required for tools to have a name so we can map the tool call to the correct tool
 		* when parsing the response.
 		*/
 		function getFunctionName(name) {
-			return name ?? options?.name ?? `extract-${++bindingIdentifier}`;
+			return name ?? `extract-${++bindingIdentifier}`;
 		}
 		if ((0, __langchain_core_utils_types.isInteropZodSchema)(schema)) {
 			const asJsonSchema$1 = (0, __langchain_core_utils_json_schema.toJsonSchema)(schema);
@@ -37,8 +38,8 @@ var ToolStrategy = class ToolStrategy {
 				type: "function",
 				function: {
 					name: getFunctionName(),
-					strict: options?.strict,
-					description: options?.description ?? asJsonSchema$1.description ?? "Tool for extracting structured output from the model's response.",
+					strict: false,
+					description: asJsonSchema$1.description ?? "Tool for extracting structured output from the model's response.",
 					parameters: asJsonSchema$1
 				}
 			};
@@ -98,7 +99,7 @@ var ProviderStrategy = class ProviderStrategy {
 			const result = validator.validate(content);
 			if (!result.valid) return;
 			return content;
-		} catch (error) {}
+		} catch {}
 	}
 };
 /**
@@ -109,10 +110,12 @@ var ProviderStrategy = class ProviderStrategy {
 * - if value is a JSON schema, default to structured output via tool calling
 * - if value is a custom response format, return it as is
 * - if value is an array, ensure all array elements are instance of `ToolStrategy`
-* @param responseFormat
+* @param responseFormat - The response format to transform, provided by the user
+* @param options - The response format options for tool strategy
+* @param model - The model to check if it supports JSON schema output
 * @returns
 */
-function transformResponseFormat(responseFormat, options) {
+function transformResponseFormat(responseFormat, options, model) {
 	if (!responseFormat) return [];
 	if (typeof responseFormat === "object" && responseFormat !== null && "__responseFormatUndefined" in responseFormat) return [];
 	/**
@@ -127,19 +130,23 @@ function transformResponseFormat(responseFormat, options) {
 		/**
 		* Check if all items are Zod schemas
 		*/
-		if (responseFormat.every((item) => (0, __langchain_core_utils_types.isInteropZodObject)(item))) return responseFormat.map((item) => ToolStrategy.fromSchema(item, void 0, options));
+		if (responseFormat.every((item) => (0, __langchain_core_utils_types.isInteropZodObject)(item))) return responseFormat.map((item) => ToolStrategy.fromSchema(item, options));
 		/**
 		* Check if all items are plain objects (JSON schema)
 		*/
-		if (responseFormat.every((item) => typeof item === "object" && item !== null && !(0, __langchain_core_utils_types.isInteropZodObject)(item))) return responseFormat.map((item) => ToolStrategy.fromSchema(item, void 0, options));
+		if (responseFormat.every((item) => typeof item === "object" && item !== null && !(0, __langchain_core_utils_types.isInteropZodObject)(item))) return responseFormat.map((item) => ToolStrategy.fromSchema(item, options));
 		throw new Error("Invalid response format: list contains mixed types.\nAll items must be either InteropZodObject or plain JSON schema objects.");
 	}
-	if ((0, __langchain_core_utils_types.isInteropZodObject)(responseFormat)) return [ToolStrategy.fromSchema(responseFormat, void 0, options)];
 	if (responseFormat instanceof ToolStrategy || responseFormat instanceof ProviderStrategy) return [responseFormat];
+	const useProviderStrategy = hasSupportForJsonSchemaOutput(model);
+	/**
+	* `responseFormat` is a Zod schema
+	*/
+	if ((0, __langchain_core_utils_types.isInteropZodObject)(responseFormat)) return useProviderStrategy ? [ProviderStrategy.fromSchema(responseFormat)] : [ToolStrategy.fromSchema(responseFormat, options)];
 	/**
 	* Handle plain object (JSON schema)
 	*/
-	if (typeof responseFormat === "object" && responseFormat !== null && "properties" in responseFormat) return [ToolStrategy.fromSchema(responseFormat, void 0, options)];
+	if (typeof responseFormat === "object" && responseFormat !== null && "properties" in responseFormat) return useProviderStrategy ? [ProviderStrategy.fromSchema(responseFormat)] : [ToolStrategy.fromSchema(responseFormat, options)];
 	throw new Error(`Invalid response format: ${String(responseFormat)}`);
 }
 /**
@@ -156,10 +163,45 @@ function toolStrategy(responseFormat, options) {
 function providerStrategy(responseFormat) {
 	return ProviderStrategy.fromSchema(responseFormat);
 }
+const CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT = ["ChatOpenAI", "ChatXAI"];
+const MODEL_NAMES_THAT_SUPPORT_JSON_SCHEMA_OUTPUT = [
+	"grok",
+	"gpt-5",
+	"gpt-4.1",
+	"gpt-4o",
+	"gpt-oss",
+	"o3-pro",
+	"o3-mini"
+];
+/**
+* Identifies the models that support JSON schema output
+* @param model - The model to check
+* @returns True if the model supports JSON schema output, false otherwise
+*/
+function hasSupportForJsonSchemaOutput(model) {
+	if (!model) return false;
+	if (typeof model === "string") {
+		const modelName = model.split(":").pop();
+		return MODEL_NAMES_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.some((modelNameSnippet) => modelName.includes(modelNameSnippet));
+	}
+	if (require_model.isConfigurableModel(model)) {
+		const configurableModel = model;
+		return hasSupportForJsonSchemaOutput(configurableModel._defaultConfig.model);
+	}
+	if (!require_model.isBaseChatModel(model)) return false;
+	const chatModelClass = model.getName();
+	/**
+	* for testing purposes only
+	*/
+	if (chatModelClass === "FakeToolCallingChatModel") return true;
+	if (CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.includes(chatModelClass) && ("model" in model && MODEL_NAMES_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.some((modelNameSnippet) => typeof model.model === "string" && model.model.includes(modelNameSnippet)) || chatModelClass === "FakeToolCallingModel" && "structuredResponse" in model)) return true;
+	return false;
+}
 
 //#endregion
 exports.ProviderStrategy = ProviderStrategy;
 exports.ToolStrategy = ToolStrategy;
+exports.hasSupportForJsonSchemaOutput = hasSupportForJsonSchemaOutput;
 exports.providerStrategy = providerStrategy;
 exports.toolStrategy = toolStrategy;
 exports.transformResponseFormat = transformResponseFormat;