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

package/dist/agents/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":["InteropZodObject","InteropZodType","LangGraphRunnableConfig","START","StateGraph","LanguageModelLike","BaseChatModel","SystemMessage","BaseMessageLike","BaseMessage","All","BaseCheckpointSaver","BaseStore","DynamicTool","StructuredToolInterface","Runnable","RunnableLike","RunnableToolLike","ToolNode","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","ResponseFormatUndefined","JsonSchemaFormat","META_EXTRAS_DESCRIPTION_PREFIX","N","ExecutedToolCall","Record","LLMCall","ExtractZodType","T","U","ExtractZodArrayTypes","Rest","A","InferResponseFormatType","ReducedZodChannel","TReducerSchema","ServerTool","ClientTool","Prompt","StateSchema","ContextSchema","Promise","AgentState","AnnotationRoot","AgentRuntime","ContextType","AbortSignal","CreateAgentParams","StructuredResponseType","DynamicLLMFunction","ResponseFormatType","ConfigurableModelInterface","InternalAgentState","WithStateGraphNodes","Graph","SD","S","K","I","O","C"],"sources":["../../src/agents/types.d.ts"],"sourcesContent":["import type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport type { LangGraphRunnableConfig, START, StateGraph } from \"@langchain/langgraph\";\nimport type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport type { SystemMessage, BaseMessageLike, BaseMessage } from \"@langchain/core/messages\";\nimport type { All, BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport type { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { Runnable, RunnableLike, RunnableToolLike } from \"@langchain/core/runnables\";\nimport type { ToolNode } from \"./nodes/ToolNode.js\";\nimport type { PreHookAnnotation, AnyAnnotationRoot, ToAnnotationRoot } from \"./annotation.js\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, ResponseFormatUndefined, JsonSchemaFormat } from \"./responses.js\";\nexport declare const META_EXTRAS_DESCRIPTION_PREFIX = \"lg:\";\nexport type N = typeof START | \"agent\" | \"tools\";\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ExecutedToolCall {\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, unknown>;\n    /**\n     * The ID of the tool call.\n     */\n    tool_id: string;\n    /**\n     * The result of the tool call (if available).\n     */\n    result?: unknown;\n}\n/**\n * Information about an LLM invocation.\n */\nexport interface LLMCall {\n    /**\n     * The messages that were sent to the LLM.\n     */\n    messages: BaseMessage[];\n    /**\n     * The response from the LLM.\n     */\n    response?: BaseMessage;\n}\n/**\n * Type helper to extract the inferred type from a single Zod schema or array of schemas\n */\nexport type ExtractZodType<T> = T extends InteropZodType<infer U> ? U : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : never;\n/**\n * Type helper to extract union type from an array of Zod schemas\n */\nexport type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;\n/**\n * Type helper to extract the structured response type from responseFormat\n */\nexport type InferResponseFormatType<T> = T extends InteropZodType<infer U> ? U extends Record<string, any> ? U : Record<string, any> : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : T extends ToolStrategy[] ? Record<string, any> // ToolStrategy arrays will be handled at runtime\n : T extends ResponseFormat ? Record<string, any> // Single ResponseFormat will be handled at runtime\n : Record<string, any>;\n/** @internal */\nexport type ReducedZodChannel<T extends InteropZodType, TReducerSchema extends InteropZodType> = T & {\n    lg_reducer_schema: TReducerSchema;\n};\nexport type ServerTool = Record<string, unknown>;\nexport type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\nexport type Prompt<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = SystemMessage | string | ((state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], config: LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>) => BaseMessageLike[] | Promise<BaseMessageLike[]>) | Runnable;\nexport type AgentState<AnnotationRoot extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = ToAnnotationRoot<AnnotationRoot>[\"State\"] & PreHookAnnotation[\"State\"];\nexport interface AgentRuntime<ContextType = Record<string, unknown>> {\n    /**\n     * The context of the agent.\n     */\n    context?: ContextType;\n    /**\n     * The store passed to the agent.\n     */\n    store?: BaseStore;\n    /**\n     * The writer of the agent to write to the output stream.\n     */\n    writer?: (chunk: unknown) => void;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n}\nexport type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nStructuredResponseType extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\n    /** The chat model that can utilize OpenAI-style tool calling. */\n    llm?: LanguageModelLike | DynamicLLMFunction<StateSchema, ContextSchema>;\n    /**\n     * Initializes a ChatModel based on the provided model name and provider.\n     * It supports various model providers and allows for runtime configuration of model parameters.\n     *\n     * @uses {@link initChatModel}\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-7-sonnet-latest\",\n     *   // ...\n     * });\n     * ```\n     */\n    model?: string;\n    /** A list of tools or a ToolNode. */\n    tools: ToolNode | (ServerTool | ClientTool)[];\n    /**\n     * An optional prompt for the LLM. This takes full graph state BEFORE the LLM is called and prepares the input to LLM.\n     *\n     * Can take a few different forms:\n     *\n     * - str: This is converted to a SystemMessage and added to the beginning of the list of messages in state[\"messages\"].\n     * - SystemMessage: this is added to the beginning of the list of messages in state[\"messages\"].\n     * - Function: This function should take in full graph state and the output is then passed to the language model.\n     * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.\n     *\n     * Note:\n     * Prior to `v0.2.46`, the prompt was set using `stateModifier` / `messagesModifier` parameters.\n     * This is now deprecated and will be removed in a future release.\n     *\n     * Cannot be used together with `prepareCall`.\n     */\n    prompt?: Prompt<StateSchema, ContextSchema>;\n    /**\n     * Additional state schema for the agent. It allows to define additional state keys that will be\n     * persisted between agent invocations.\n     *\n     * @example\n     * ```ts\n     * // State schema defines data that persists across agent invocations\n     * const stateSchema = z.object({\n     *   userPreferences: z.object({\n     *     theme: z.enum([\"light\", \"dark\"]),\n     *     language: z.string(),\n     *   }),\n     *   taskHistory: z.array(z.string()),\n     *   currentWorkflow: z.string().optional(),\n     * });\n     *\n     * // Context schema defines runtime parameters passed per invocation\n     * const contextSchema = z.object({ ... });\n     *\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [updatePreferences, addTask],\n     *   stateSchema,    // Persisted: preferences, e.g. task history, workflow state\n     *   contextSchema,  // Per-invocation: user ID, session, API keys, etc.\n     *   prompt: (state, config) => {\n     *     // ...\n     *   },\n     * });\n     *\n     * // First invocation - state starts empty, context provided\n     * await agent.invoke({\n     *   messages: [new HumanMessage(\"Set my theme to dark\")],\n     * }, {\n     *   context: { userId: \"user123\", sessionId: \"sess456\", apiKeys: {...} }\n     * });\n     *\n     * // Second invocation - state persists, new context\n     * await agent.invoke({\n     *   messages: [new HumanMessage(\"Add a task to review code\")],\n     * }, {\n     *   context: { userId: \"user123\", sessionId: \"sess789\", apiKeys: {...} }\n     * });\n     * // State now contains: userPreferences.theme=\"dark\", taskHistory=[\"review code\"]\n     * ```\n     */\n    stateSchema?: StateSchema;\n    /**\n     * An optional schema for the context. It allows to pass in a typed context object into the agent\n     * invocation and allows to access it in hooks such as `prompt`, `preModelHook`, `postModelHook`, etc.\n     * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between\n     * agent invocations.\n     *\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [getWeather],\n     *   contextSchema: z.object({\n     *     capital: z.string(),\n     *   }),\n     *   prompt: (state, config) => {\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. The capital of France is ${config.context.capital}.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new SystemMessage(\"You are a helpful assistant.\"),\n     *     new HumanMessage(\"What is the capital of France?\"),\n     *   ],\n     * }, {\n     *   context: {\n     *     capital: \"Paris\",\n     *   },\n     * });\n     * ```\n     */\n    contextSchema?: ContextSchema;\n    /** An optional checkpoint saver to persist the agent's state. */\n    checkpointSaver?: BaseCheckpointSaver | boolean;\n    /** An optional checkpoint saver to persist the agent's state. Alias of \"checkpointSaver\". */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /** An optional list of node names to interrupt before running. */\n    interruptBefore?: N[] | All;\n    /** An optional list of node names to interrupt after running. */\n    interruptAfter?: N[] | All;\n    store?: BaseStore;\n    /**\n     * An optional schema for the final agent output.\n     *\n     * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.\n     * If not provided, `structuredResponse` will not be present in the output state.\n     *\n     * Can be passed in as:\n     *   - Zod schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: z.object({\n     *         capital: z.string(),\n     *       }),\n     *       // ...\n     *     });\n     *     ```\n     *   - JSON schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: {\n     *         type: \"json_schema\",\n     *         schema: {\n     *           type: \"object\",\n     *           properties: {\n     *             capital: { type: \"string\" },\n     *           },\n     *           required: [\"capital\"],\n     *         },\n     *       },\n     *       // ...\n     *     });\n     *     ```\n     *   - Create React Agent ResponseFormat\n     *     ```ts\n     *     import { providerStrategy, toolStrategy } from \"langchain\";\n     *     const agent = createAgent({\n     *       responseFormat: providerStrategy(\n     *         z.object({\n     *           capital: z.string(),\n     *         })\n     *       ),\n     *       // or\n     *       responseFormat: [\n     *         toolStrategy({ ... }),\n     *         toolStrategy({ ... }),\n     *       ]\n     *       // ...\n     *     });\n     *     ```\n     *\n     * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.\n     * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).\n     */\n    responseFormat?: ResponseFormatType;\n    /**\n     * An optional name for the agent.\n     */\n    name?: string;\n    /**\n     * An optional description for the agent.\n     * This can be used to describe the agent to the underlying supervisor LLM.\n     */\n    description?: string;\n    /**\n     * Use to specify how to expose the agent name to the underlying supervisor LLM.\n     *   - `undefined`: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.\n     *   - `\"inline\"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.\n     *       Example: `\"How can I help you\"` -> `\"<name>agent_name</name><content>How can I help you?</content>\"`\n     */\n    includeAgentName?: \"inline\" | undefined;\n    /**\n     * An optional node to add before the `agent` node (i.e., the node that calls the LLM).\n     * Useful for managing long message histories (e.g., message trimming, summarization, etc.).\n     */\n    preModelHook?: RunnableLike<ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<StateSchema>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>>;\n    /**\n     * An optional node to add after the `agent` node (i.e., the node that calls the LLM).\n     * Useful for implementing human-in-the-loop, guardrails, validation, or other post-processing.\n     */\n    postModelHook?: RunnableLike<ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<StateSchema>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>>;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n    /**\n     * Determines the version of the graph to create.\n     *\n     * Can be one of\n     * - `\"v1\"`: The tool node processes a single message. All tool calls in the message are\n     *           executed in parallel within the tool node.\n     * - `\"v2\"`: The tool node processes a single tool call. Tool calls are distributed across\n     *           multiple instances of the tool node using the Send API.\n     *\n     * @default `\"v2\"`\n     */\n    version?: \"v1\" | \"v2\";\n};\nexport interface ConfigurableModelInterface {\n    _queuedMethodOperations: Record<string, unknown>;\n    _model: () => Promise<BaseChatModel>;\n}\nexport type InternalAgentState<StructuredResponseType extends Record<string, unknown> | undefined = Record<string, unknown>> = {\n    messages: BaseMessage[];\n} & (StructuredResponseType extends ResponseFormatUndefined ? Record<string, never> : {\n    structuredResponse: StructuredResponseType;\n});\nexport type WithStateGraphNodes<K extends string, Graph> = Graph extends StateGraph<infer SD, infer S, infer U, infer N, infer I, infer O, infer C> ? StateGraph<SD, S, U, N | K, I, O, C> : never;\n/**\n * @deprecated likely to be removed in the next version of the agent\n */\ntype DynamicLLMFunction<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = (state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], runtime: AgentRuntime<ToAnnotationRoot<ContextSchema>[\"State\"]>) => Promise<LanguageModelLike> | LanguageModelLike;\nexport {};\n"],"mappings":"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"}
+{"version":3,"file":"types.d.cts","names":["InteropZodObject","InteropZodType","LangGraphRunnableConfig","START","StateGraph","LanguageModelLike","SystemMessage","BaseMessageLike","BaseMessage","All","BaseCheckpointSaver","BaseStore","DynamicTool","StructuredToolInterface","Runnable","RunnableLike","RunnableToolLike","ToolNode","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","ResponseFormatUndefined","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","JsonSchemaFormat","META_EXTRAS_DESCRIPTION_PREFIX","N","ExecutedToolCall","Record","LLMCall","ExtractZodType","T","U","ExtractZodArrayTypes","Rest","A","InferResponseFormatType","ReducedZodChannel","TReducerSchema","ServerTool","ClientTool","Prompt","StateSchema","ContextSchema","Promise","AgentState","AnnotationRoot","AgentRuntime","ContextType","AbortSignal","CreateAgentParams","StructuredResponseType","DynamicLLMFunction","ResponseFormatType","InternalAgentState","WithStateGraphNodes","Graph","SD","S","K","I","O","C"],"sources":["../../src/agents/types.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport type { LangGraphRunnableConfig, START, StateGraph } from \"@langchain/langgraph\";\nimport type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { SystemMessage, BaseMessageLike, BaseMessage } from \"@langchain/core/messages\";\nimport type { All, BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport type { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { Runnable, RunnableLike, RunnableToolLike } from \"@langchain/core/runnables\";\nimport type { ToolNode } from \"./nodes/ToolNode.js\";\nimport type { PreHookAnnotation, AnyAnnotationRoot, ToAnnotationRoot, ResponseFormatUndefined } from \"./annotation.js\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, JsonSchemaFormat } from \"./responses.js\";\nexport declare const META_EXTRAS_DESCRIPTION_PREFIX = \"lg:\";\nexport type N = typeof START | \"agent\" | \"tools\";\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ExecutedToolCall {\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, unknown>;\n    /**\n     * The ID of the tool call.\n     */\n    tool_id: string;\n    /**\n     * The result of the tool call (if available).\n     */\n    result?: unknown;\n}\n/**\n * Information about an LLM invocation.\n */\nexport interface LLMCall {\n    /**\n     * The messages that were sent to the LLM.\n     */\n    messages: BaseMessage[];\n    /**\n     * The response from the LLM.\n     */\n    response?: BaseMessage;\n}\n/**\n * Type helper to extract the inferred type from a single Zod schema or array of schemas\n */\nexport type ExtractZodType<T> = T extends InteropZodType<infer U> ? U : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : never;\n/**\n * Type helper to extract union type from an array of Zod schemas\n */\nexport type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;\n/**\n * Type helper to extract the structured response type from responseFormat\n */\nexport type InferResponseFormatType<T> = T extends InteropZodType<infer U> ? U extends Record<string, any> ? U : Record<string, any> : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : T extends ToolStrategy[] ? Record<string, any> // ToolStrategy arrays will be handled at runtime\n : T extends ResponseFormat ? Record<string, any> // Single ResponseFormat will be handled at runtime\n : Record<string, any>;\n/** @internal */\nexport type ReducedZodChannel<T extends InteropZodType, TReducerSchema extends InteropZodType> = T & {\n    lg_reducer_schema: TReducerSchema;\n};\nexport type ServerTool = Record<string, unknown>;\nexport type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\nexport type Prompt<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = SystemMessage | string | ((state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], config: LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>) => BaseMessageLike[] | Promise<BaseMessageLike[]>) | Runnable;\nexport type AgentState<AnnotationRoot extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = ToAnnotationRoot<AnnotationRoot>[\"State\"] & PreHookAnnotation[\"State\"];\nexport interface AgentRuntime<ContextType = Record<string, unknown>> {\n    /**\n     * The context of the agent.\n     */\n    context?: ContextType;\n    /**\n     * The store passed to the agent.\n     */\n    store?: BaseStore;\n    /**\n     * The writer of the agent to write to the output stream.\n     */\n    writer?: (chunk: unknown) => void;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n}\nexport type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, StructuredResponseType extends Record<string, unknown> = Record<string, unknown>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\n    /** The chat model that can utilize OpenAI-style tool calling. */\n    llm?: LanguageModelLike | DynamicLLMFunction<StateSchema, ContextSchema>;\n    /**\n     * Initializes a ChatModel based on the provided model name and provider.\n     * It supports various model providers and allows for runtime configuration of model parameters.\n     *\n     * @uses {@link initChatModel}\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-7-sonnet-latest\",\n     *   // ...\n     * });\n     * ```\n     */\n    model?: string;\n    /** A list of tools or a ToolNode. */\n    tools: ToolNode | (ServerTool | ClientTool)[];\n    /**\n     * An optional prompt for the LLM. This takes full graph state BEFORE the LLM is called and prepares the input to LLM.\n     *\n     * Can take a few different forms:\n     *\n     * - str: This is converted to a SystemMessage and added to the beginning of the list of messages in state[\"messages\"].\n     * - SystemMessage: this is added to the beginning of the list of messages in state[\"messages\"].\n     * - Function: This function should take in full graph state and the output is then passed to the language model.\n     * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.\n     *\n     * Note:\n     * Prior to `v0.2.46`, the prompt was set using `stateModifier` / `messagesModifier` parameters.\n     * This is now deprecated and will be removed in a future release.\n     *\n     * Cannot be used together with `prepareCall`.\n     */\n    prompt?: Prompt<StateSchema, ContextSchema>;\n    /**\n     * Additional state schema for the agent. It allows to define additional state keys that will be\n     * persisted between agent invocations.\n     *\n     * @example\n     * ```ts\n     * // State schema defines data that persists across agent invocations\n     * const stateSchema = z.object({\n     *   userPreferences: z.object({\n     *     theme: z.enum([\"light\", \"dark\"]),\n     *     language: z.string(),\n     *   }),\n     *   taskHistory: z.array(z.string()),\n     *   currentWorkflow: z.string().optional(),\n     * });\n     *\n     * // Context schema defines runtime parameters passed per invocation\n     * const contextSchema = z.object({ ... });\n     *\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [updatePreferences, addTask],\n     *   stateSchema,    // Persisted: preferences, e.g. task history, workflow state\n     *   contextSchema,  // Per-invocation: user ID, session, API keys, etc.\n     *   prompt: (state, config) => {\n     *     // ...\n     *   },\n     * });\n     *\n     * // First invocation - state starts empty, context provided\n     * await agent.invoke({\n     *   messages: [new HumanMessage(\"Set my theme to dark\")],\n     * }, {\n     *   context: { userId: \"user123\", sessionId: \"sess456\", apiKeys: {...} }\n     * });\n     *\n     * // Second invocation - state persists, new context\n     * await agent.invoke({\n     *   messages: [new HumanMessage(\"Add a task to review code\")],\n     * }, {\n     *   context: { userId: \"user123\", sessionId: \"sess789\", apiKeys: {...} }\n     * });\n     * // State now contains: userPreferences.theme=\"dark\", taskHistory=[\"review code\"]\n     * ```\n     */\n    stateSchema?: StateSchema;\n    /**\n     * An optional schema for the context. It allows to pass in a typed context object into the agent\n     * invocation and allows to access it in hooks such as `prompt`, `preModelHook`, `postModelHook`, etc.\n     * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between\n     * agent invocations.\n     *\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [getWeather],\n     *   contextSchema: z.object({\n     *     capital: z.string(),\n     *   }),\n     *   prompt: (state, config) => {\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. The capital of France is ${config.context.capital}.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new SystemMessage(\"You are a helpful assistant.\"),\n     *     new HumanMessage(\"What is the capital of France?\"),\n     *   ],\n     * }, {\n     *   context: {\n     *     capital: \"Paris\",\n     *   },\n     * });\n     * ```\n     */\n    contextSchema?: ContextSchema;\n    /** An optional checkpoint saver to persist the agent's state. */\n    checkpointSaver?: BaseCheckpointSaver | boolean;\n    /** An optional checkpoint saver to persist the agent's state. Alias of \"checkpointSaver\". */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /** An optional list of node names to interrupt before running. */\n    interruptBefore?: N[] | All;\n    /** An optional list of node names to interrupt after running. */\n    interruptAfter?: N[] | All;\n    store?: BaseStore;\n    /**\n     * An optional schema for the final agent output.\n     *\n     * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.\n     * If not provided, `structuredResponse` will not be present in the output state.\n     *\n     * Can be passed in as:\n     *   - Zod schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: z.object({\n     *         capital: z.string(),\n     *       }),\n     *       // ...\n     *     });\n     *     ```\n     *   - JSON schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: {\n     *         type: \"json_schema\",\n     *         schema: {\n     *           type: \"object\",\n     *           properties: {\n     *             capital: { type: \"string\" },\n     *           },\n     *           required: [\"capital\"],\n     *         },\n     *       },\n     *       // ...\n     *     });\n     *     ```\n     *   - Create React Agent ResponseFormat\n     *     ```ts\n     *     import { providerStrategy, toolStrategy } from \"langchain\";\n     *     const agent = createAgent({\n     *       responseFormat: providerStrategy(\n     *         z.object({\n     *           capital: z.string(),\n     *         })\n     *       ),\n     *       // or\n     *       responseFormat: [\n     *         toolStrategy({ ... }),\n     *         toolStrategy({ ... }),\n     *       ]\n     *       // ...\n     *     });\n     *     ```\n     *\n     * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.\n     * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).\n     */\n    responseFormat?: ResponseFormatType;\n    /**\n     * An optional name for the agent.\n     */\n    name?: string;\n    /**\n     * An optional description for the agent.\n     * This can be used to describe the agent to the underlying supervisor LLM.\n     */\n    description?: string;\n    /**\n     * Use to specify how to expose the agent name to the underlying supervisor LLM.\n     *   - `undefined`: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.\n     *   - `\"inline\"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.\n     *       Example: `\"How can I help you\"` -> `\"<name>agent_name</name><content>How can I help you?</content>\"`\n     */\n    includeAgentName?: \"inline\" | undefined;\n    /**\n     * An optional node to add before the `agent` node (i.e., the node that calls the LLM).\n     * Useful for managing long message histories (e.g., message trimming, summarization, etc.).\n     */\n    preModelHook?: RunnableLike<ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<StateSchema>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>>;\n    /**\n     * An optional node to add after the `agent` node (i.e., the node that calls the LLM).\n     * Useful for implementing human-in-the-loop, guardrails, validation, or other post-processing.\n     */\n    postModelHook?: RunnableLike<ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<StateSchema>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>>;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n    /**\n     * Determines the version of the graph to create.\n     *\n     * Can be one of\n     * - `\"v1\"`: The tool node processes a single message. All tool calls in the message are\n     *           executed in parallel within the tool node.\n     * - `\"v2\"`: The tool node processes a single tool call. Tool calls are distributed across\n     *           multiple instances of the tool node using the Send API.\n     *\n     * @default `\"v2\"`\n     */\n    version?: \"v1\" | \"v2\";\n};\nexport type InternalAgentState<StructuredResponseType extends Record<string, unknown> | undefined = Record<string, unknown>> = {\n    messages: BaseMessage[];\n} & (StructuredResponseType extends ResponseFormatUndefined ? Record<string, never> : {\n    structuredResponse: StructuredResponseType;\n});\nexport type WithStateGraphNodes<K extends string, Graph> = Graph extends StateGraph<infer SD, infer S, infer U, infer N, infer I, infer O, infer C> ? StateGraph<SD, S, U, N | K, I, O, C> : never;\n/**\n * @deprecated likely to be removed in the next version of the agent\n */\ntype DynamicLLMFunction<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = (state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], runtime: AgentRuntime<ToAnnotationRoot<ContextSchema>[\"State\"]>) => Promise<LanguageModelLike> | LanguageModelLike;\nexport {};\n"],"mappings":"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"}

package/dist/agents/types.d.ts

@@ -1,8 +1,7 @@
-import { JsonSchemaFormat, ProviderStrategy, ResponseFormat, ResponseFormatUndefined, ToolStrategy, TypedToolStrategy } from "./responses.js";
-import { AnyAnnotationRoot, PreHookAnnotation, ToAnnotationRoot } from "./annotation.js";
+import { AnyAnnotationRoot, PreHookAnnotation, ResponseFormatUndefined, ToAnnotationRoot } from "./annotation.js";
+import { JsonSchemaFormat, ProviderStrategy, ResponseFormat, ToolStrategy, TypedToolStrategy } from "./responses.js";
 import { ToolNode } from "./nodes/ToolNode.js";
 import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/messages";
-import { BaseChatModel } from "@langchain/core/language_models/chat_models";
 import { Runnable, RunnableLike, RunnableToolLike } from "@langchain/core/runnables";
 import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
 import { LangGraphRunnableConfig, START, StateGraph } from "@langchain/langgraph";
@@ -46,9 +45,7 @@ interface AgentRuntime<ContextType = Record<string, unknown>> {
    */
   signal?: AbortSignal;
 }
-type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-StructuredResponseType extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {
+type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, StructuredResponseType extends Record<string, unknown> = Record<string, unknown>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {
   /** The chat model that can utilize OpenAI-style tool calling. */
   llm?: LanguageModelLike | DynamicLLMFunction<StateSchema, ContextSchema>;
   /**

package/dist/agents/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":["InteropZodObject","InteropZodType","LangGraphRunnableConfig","START","StateGraph","LanguageModelLike","BaseChatModel","SystemMessage","BaseMessageLike","BaseMessage","All","BaseCheckpointSaver","BaseStore","DynamicTool","StructuredToolInterface","Runnable","RunnableLike","RunnableToolLike","ToolNode","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","ResponseFormatUndefined","JsonSchemaFormat","META_EXTRAS_DESCRIPTION_PREFIX","N","ExecutedToolCall","Record","LLMCall","ExtractZodType","T","U","ExtractZodArrayTypes","Rest","A","InferResponseFormatType","ReducedZodChannel","TReducerSchema","ServerTool","ClientTool","Prompt","StateSchema","ContextSchema","Promise","AgentState","AnnotationRoot","AgentRuntime","ContextType","AbortSignal","CreateAgentParams","StructuredResponseType","DynamicLLMFunction","ResponseFormatType","ConfigurableModelInterface","InternalAgentState","WithStateGraphNodes","Graph","SD","S","K","I","O","C"],"sources":["../../src/agents/types.d.ts"],"sourcesContent":["import type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport type { LangGraphRunnableConfig, START, StateGraph } from \"@langchain/langgraph\";\nimport type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport type { SystemMessage, BaseMessageLike, BaseMessage } from \"@langchain/core/messages\";\nimport type { All, BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport type { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { Runnable, RunnableLike, RunnableToolLike } from \"@langchain/core/runnables\";\nimport type { ToolNode } from \"./nodes/ToolNode.js\";\nimport type { PreHookAnnotation, AnyAnnotationRoot, ToAnnotationRoot } from \"./annotation.js\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, ResponseFormatUndefined, JsonSchemaFormat } from \"./responses.js\";\nexport declare const META_EXTRAS_DESCRIPTION_PREFIX = \"lg:\";\nexport type N = typeof START | \"agent\" | \"tools\";\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ExecutedToolCall {\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, unknown>;\n    /**\n     * The ID of the tool call.\n     */\n    tool_id: string;\n    /**\n     * The result of the tool call (if available).\n     */\n    result?: unknown;\n}\n/**\n * Information about an LLM invocation.\n */\nexport interface LLMCall {\n    /**\n     * The messages that were sent to the LLM.\n     */\n    messages: BaseMessage[];\n    /**\n     * The response from the LLM.\n     */\n    response?: BaseMessage;\n}\n/**\n * Type helper to extract the inferred type from a single Zod schema or array of schemas\n */\nexport type ExtractZodType<T> = T extends InteropZodType<infer U> ? U : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : never;\n/**\n * Type helper to extract union type from an array of Zod schemas\n */\nexport type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;\n/**\n * Type helper to extract the structured response type from responseFormat\n */\nexport type InferResponseFormatType<T> = T extends InteropZodType<infer U> ? U extends Record<string, any> ? U : Record<string, any> : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : T extends ToolStrategy[] ? Record<string, any> // ToolStrategy arrays will be handled at runtime\n : T extends ResponseFormat ? Record<string, any> // Single ResponseFormat will be handled at runtime\n : Record<string, any>;\n/** @internal */\nexport type ReducedZodChannel<T extends InteropZodType, TReducerSchema extends InteropZodType> = T & {\n    lg_reducer_schema: TReducerSchema;\n};\nexport type ServerTool = Record<string, unknown>;\nexport type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\nexport type Prompt<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = SystemMessage | string | ((state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], config: LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>) => BaseMessageLike[] | Promise<BaseMessageLike[]>) | Runnable;\nexport type AgentState<AnnotationRoot extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = ToAnnotationRoot<AnnotationRoot>[\"State\"] & PreHookAnnotation[\"State\"];\nexport interface AgentRuntime<ContextType = Record<string, unknown>> {\n    /**\n     * The context of the agent.\n     */\n    context?: ContextType;\n    /**\n     * The store passed to the agent.\n     */\n    store?: BaseStore;\n    /**\n     * The writer of the agent to write to the output stream.\n     */\n    writer?: (chunk: unknown) => void;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n}\nexport type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nStructuredResponseType extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\n    /** The chat model that can utilize OpenAI-style tool calling. */\n    llm?: LanguageModelLike | DynamicLLMFunction<StateSchema, ContextSchema>;\n    /**\n     * Initializes a ChatModel based on the provided model name and provider.\n     * It supports various model providers and allows for runtime configuration of model parameters.\n     *\n     * @uses {@link initChatModel}\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-7-sonnet-latest\",\n     *   // ...\n     * });\n     * ```\n     */\n    model?: string;\n    /** A list of tools or a ToolNode. */\n    tools: ToolNode | (ServerTool | ClientTool)[];\n    /**\n     * An optional prompt for the LLM. This takes full graph state BEFORE the LLM is called and prepares the input to LLM.\n     *\n     * Can take a few different forms:\n     *\n     * - str: This is converted to a SystemMessage and added to the beginning of the list of messages in state[\"messages\"].\n     * - SystemMessage: this is added to the beginning of the list of messages in state[\"messages\"].\n     * - Function: This function should take in full graph state and the output is then passed to the language model.\n     * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.\n     *\n     * Note:\n     * Prior to `v0.2.46`, the prompt was set using `stateModifier` / `messagesModifier` parameters.\n     * This is now deprecated and will be removed in a future release.\n     *\n     * Cannot be used together with `prepareCall`.\n     */\n    prompt?: Prompt<StateSchema, ContextSchema>;\n    /**\n     * Additional state schema for the agent. It allows to define additional state keys that will be\n     * persisted between agent invocations.\n     *\n     * @example\n     * ```ts\n     * // State schema defines data that persists across agent invocations\n     * const stateSchema = z.object({\n     *   userPreferences: z.object({\n     *     theme: z.enum([\"light\", \"dark\"]),\n     *     language: z.string(),\n     *   }),\n     *   taskHistory: z.array(z.string()),\n     *   currentWorkflow: z.string().optional(),\n     * });\n     *\n     * // Context schema defines runtime parameters passed per invocation\n     * const contextSchema = z.object({ ... });\n     *\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [updatePreferences, addTask],\n     *   stateSchema,    // Persisted: preferences, e.g. task history, workflow state\n     *   contextSchema,  // Per-invocation: user ID, session, API keys, etc.\n     *   prompt: (state, config) => {\n     *     // ...\n     *   },\n     * });\n     *\n     * // First invocation - state starts empty, context provided\n     * await agent.invoke({\n     *   messages: [new HumanMessage(\"Set my theme to dark\")],\n     * }, {\n     *   context: { userId: \"user123\", sessionId: \"sess456\", apiKeys: {...} }\n     * });\n     *\n     * // Second invocation - state persists, new context\n     * await agent.invoke({\n     *   messages: [new HumanMessage(\"Add a task to review code\")],\n     * }, {\n     *   context: { userId: \"user123\", sessionId: \"sess789\", apiKeys: {...} }\n     * });\n     * // State now contains: userPreferences.theme=\"dark\", taskHistory=[\"review code\"]\n     * ```\n     */\n    stateSchema?: StateSchema;\n    /**\n     * An optional schema for the context. It allows to pass in a typed context object into the agent\n     * invocation and allows to access it in hooks such as `prompt`, `preModelHook`, `postModelHook`, etc.\n     * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between\n     * agent invocations.\n     *\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [getWeather],\n     *   contextSchema: z.object({\n     *     capital: z.string(),\n     *   }),\n     *   prompt: (state, config) => {\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. The capital of France is ${config.context.capital}.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new SystemMessage(\"You are a helpful assistant.\"),\n     *     new HumanMessage(\"What is the capital of France?\"),\n     *   ],\n     * }, {\n     *   context: {\n     *     capital: \"Paris\",\n     *   },\n     * });\n     * ```\n     */\n    contextSchema?: ContextSchema;\n    /** An optional checkpoint saver to persist the agent's state. */\n    checkpointSaver?: BaseCheckpointSaver | boolean;\n    /** An optional checkpoint saver to persist the agent's state. Alias of \"checkpointSaver\". */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /** An optional list of node names to interrupt before running. */\n    interruptBefore?: N[] | All;\n    /** An optional list of node names to interrupt after running. */\n    interruptAfter?: N[] | All;\n    store?: BaseStore;\n    /**\n     * An optional schema for the final agent output.\n     *\n     * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.\n     * If not provided, `structuredResponse` will not be present in the output state.\n     *\n     * Can be passed in as:\n     *   - Zod schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: z.object({\n     *         capital: z.string(),\n     *       }),\n     *       // ...\n     *     });\n     *     ```\n     *   - JSON schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: {\n     *         type: \"json_schema\",\n     *         schema: {\n     *           type: \"object\",\n     *           properties: {\n     *             capital: { type: \"string\" },\n     *           },\n     *           required: [\"capital\"],\n     *         },\n     *       },\n     *       // ...\n     *     });\n     *     ```\n     *   - Create React Agent ResponseFormat\n     *     ```ts\n     *     import { providerStrategy, toolStrategy } from \"langchain\";\n     *     const agent = createAgent({\n     *       responseFormat: providerStrategy(\n     *         z.object({\n     *           capital: z.string(),\n     *         })\n     *       ),\n     *       // or\n     *       responseFormat: [\n     *         toolStrategy({ ... }),\n     *         toolStrategy({ ... }),\n     *       ]\n     *       // ...\n     *     });\n     *     ```\n     *\n     * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.\n     * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).\n     */\n    responseFormat?: ResponseFormatType;\n    /**\n     * An optional name for the agent.\n     */\n    name?: string;\n    /**\n     * An optional description for the agent.\n     * This can be used to describe the agent to the underlying supervisor LLM.\n     */\n    description?: string;\n    /**\n     * Use to specify how to expose the agent name to the underlying supervisor LLM.\n     *   - `undefined`: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.\n     *   - `\"inline\"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.\n     *       Example: `\"How can I help you\"` -> `\"<name>agent_name</name><content>How can I help you?</content>\"`\n     */\n    includeAgentName?: \"inline\" | undefined;\n    /**\n     * An optional node to add before the `agent` node (i.e., the node that calls the LLM).\n     * Useful for managing long message histories (e.g., message trimming, summarization, etc.).\n     */\n    preModelHook?: RunnableLike<ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<StateSchema>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>>;\n    /**\n     * An optional node to add after the `agent` node (i.e., the node that calls the LLM).\n     * Useful for implementing human-in-the-loop, guardrails, validation, or other post-processing.\n     */\n    postModelHook?: RunnableLike<ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<StateSchema>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>>;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n    /**\n     * Determines the version of the graph to create.\n     *\n     * Can be one of\n     * - `\"v1\"`: The tool node processes a single message. All tool calls in the message are\n     *           executed in parallel within the tool node.\n     * - `\"v2\"`: The tool node processes a single tool call. Tool calls are distributed across\n     *           multiple instances of the tool node using the Send API.\n     *\n     * @default `\"v2\"`\n     */\n    version?: \"v1\" | \"v2\";\n};\nexport interface ConfigurableModelInterface {\n    _queuedMethodOperations: Record<string, unknown>;\n    _model: () => Promise<BaseChatModel>;\n}\nexport type InternalAgentState<StructuredResponseType extends Record<string, unknown> | undefined = Record<string, unknown>> = {\n    messages: BaseMessage[];\n} & (StructuredResponseType extends ResponseFormatUndefined ? Record<string, never> : {\n    structuredResponse: StructuredResponseType;\n});\nexport type WithStateGraphNodes<K extends string, Graph> = Graph extends StateGraph<infer SD, infer S, infer U, infer N, infer I, infer O, infer C> ? StateGraph<SD, S, U, N | K, I, O, C> : never;\n/**\n * @deprecated likely to be removed in the next version of the agent\n */\ntype DynamicLLMFunction<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = (state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], runtime: AgentRuntime<ToAnnotationRoot<ContextSchema>[\"State\"]>) => Promise<LanguageModelLike> | LanguageModelLike;\nexport {};\n"],"mappings":"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"}
+{"version":3,"file":"types.d.ts","names":["InteropZodObject","InteropZodType","LangGraphRunnableConfig","START","StateGraph","LanguageModelLike","SystemMessage","BaseMessageLike","BaseMessage","All","BaseCheckpointSaver","BaseStore","DynamicTool","StructuredToolInterface","Runnable","RunnableLike","RunnableToolLike","ToolNode","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","ResponseFormatUndefined","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","JsonSchemaFormat","META_EXTRAS_DESCRIPTION_PREFIX","N","ExecutedToolCall","Record","LLMCall","ExtractZodType","T","U","ExtractZodArrayTypes","Rest","A","InferResponseFormatType","ReducedZodChannel","TReducerSchema","ServerTool","ClientTool","Prompt","StateSchema","ContextSchema","Promise","AgentState","AnnotationRoot","AgentRuntime","ContextType","AbortSignal","CreateAgentParams","StructuredResponseType","DynamicLLMFunction","ResponseFormatType","InternalAgentState","WithStateGraphNodes","Graph","SD","S","K","I","O","C"],"sources":["../../src/agents/types.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport type { LangGraphRunnableConfig, START, StateGraph } from \"@langchain/langgraph\";\nimport type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { SystemMessage, BaseMessageLike, BaseMessage } from \"@langchain/core/messages\";\nimport type { All, BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport type { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { Runnable, RunnableLike, RunnableToolLike } from \"@langchain/core/runnables\";\nimport type { ToolNode } from \"./nodes/ToolNode.js\";\nimport type { PreHookAnnotation, AnyAnnotationRoot, ToAnnotationRoot, ResponseFormatUndefined } from \"./annotation.js\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, JsonSchemaFormat } from \"./responses.js\";\nexport declare const META_EXTRAS_DESCRIPTION_PREFIX = \"lg:\";\nexport type N = typeof START | \"agent\" | \"tools\";\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ExecutedToolCall {\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, unknown>;\n    /**\n     * The ID of the tool call.\n     */\n    tool_id: string;\n    /**\n     * The result of the tool call (if available).\n     */\n    result?: unknown;\n}\n/**\n * Information about an LLM invocation.\n */\nexport interface LLMCall {\n    /**\n     * The messages that were sent to the LLM.\n     */\n    messages: BaseMessage[];\n    /**\n     * The response from the LLM.\n     */\n    response?: BaseMessage;\n}\n/**\n * Type helper to extract the inferred type from a single Zod schema or array of schemas\n */\nexport type ExtractZodType<T> = T extends InteropZodType<infer U> ? U : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : never;\n/**\n * Type helper to extract union type from an array of Zod schemas\n */\nexport type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;\n/**\n * Type helper to extract the structured response type from responseFormat\n */\nexport type InferResponseFormatType<T> = T extends InteropZodType<infer U> ? U extends Record<string, any> ? U : Record<string, any> : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : T extends ToolStrategy[] ? Record<string, any> // ToolStrategy arrays will be handled at runtime\n : T extends ResponseFormat ? Record<string, any> // Single ResponseFormat will be handled at runtime\n : Record<string, any>;\n/** @internal */\nexport type ReducedZodChannel<T extends InteropZodType, TReducerSchema extends InteropZodType> = T & {\n    lg_reducer_schema: TReducerSchema;\n};\nexport type ServerTool = Record<string, unknown>;\nexport type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\nexport type Prompt<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = SystemMessage | string | ((state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], config: LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>) => BaseMessageLike[] | Promise<BaseMessageLike[]>) | Runnable;\nexport type AgentState<AnnotationRoot extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = ToAnnotationRoot<AnnotationRoot>[\"State\"] & PreHookAnnotation[\"State\"];\nexport interface AgentRuntime<ContextType = Record<string, unknown>> {\n    /**\n     * The context of the agent.\n     */\n    context?: ContextType;\n    /**\n     * The store passed to the agent.\n     */\n    store?: BaseStore;\n    /**\n     * The writer of the agent to write to the output stream.\n     */\n    writer?: (chunk: unknown) => void;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n}\nexport type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, StructuredResponseType extends Record<string, unknown> = Record<string, unknown>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\n    /** The chat model that can utilize OpenAI-style tool calling. */\n    llm?: LanguageModelLike | DynamicLLMFunction<StateSchema, ContextSchema>;\n    /**\n     * Initializes a ChatModel based on the provided model name and provider.\n     * It supports various model providers and allows for runtime configuration of model parameters.\n     *\n     * @uses {@link initChatModel}\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-7-sonnet-latest\",\n     *   // ...\n     * });\n     * ```\n     */\n    model?: string;\n    /** A list of tools or a ToolNode. */\n    tools: ToolNode | (ServerTool | ClientTool)[];\n    /**\n     * An optional prompt for the LLM. This takes full graph state BEFORE the LLM is called and prepares the input to LLM.\n     *\n     * Can take a few different forms:\n     *\n     * - str: This is converted to a SystemMessage and added to the beginning of the list of messages in state[\"messages\"].\n     * - SystemMessage: this is added to the beginning of the list of messages in state[\"messages\"].\n     * - Function: This function should take in full graph state and the output is then passed to the language model.\n     * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.\n     *\n     * Note:\n     * Prior to `v0.2.46`, the prompt was set using `stateModifier` / `messagesModifier` parameters.\n     * This is now deprecated and will be removed in a future release.\n     *\n     * Cannot be used together with `prepareCall`.\n     */\n    prompt?: Prompt<StateSchema, ContextSchema>;\n    /**\n     * Additional state schema for the agent. It allows to define additional state keys that will be\n     * persisted between agent invocations.\n     *\n     * @example\n     * ```ts\n     * // State schema defines data that persists across agent invocations\n     * const stateSchema = z.object({\n     *   userPreferences: z.object({\n     *     theme: z.enum([\"light\", \"dark\"]),\n     *     language: z.string(),\n     *   }),\n     *   taskHistory: z.array(z.string()),\n     *   currentWorkflow: z.string().optional(),\n     * });\n     *\n     * // Context schema defines runtime parameters passed per invocation\n     * const contextSchema = z.object({ ... });\n     *\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [updatePreferences, addTask],\n     *   stateSchema,    // Persisted: preferences, e.g. task history, workflow state\n     *   contextSchema,  // Per-invocation: user ID, session, API keys, etc.\n     *   prompt: (state, config) => {\n     *     // ...\n     *   },\n     * });\n     *\n     * // First invocation - state starts empty, context provided\n     * await agent.invoke({\n     *   messages: [new HumanMessage(\"Set my theme to dark\")],\n     * }, {\n     *   context: { userId: \"user123\", sessionId: \"sess456\", apiKeys: {...} }\n     * });\n     *\n     * // Second invocation - state persists, new context\n     * await agent.invoke({\n     *   messages: [new HumanMessage(\"Add a task to review code\")],\n     * }, {\n     *   context: { userId: \"user123\", sessionId: \"sess789\", apiKeys: {...} }\n     * });\n     * // State now contains: userPreferences.theme=\"dark\", taskHistory=[\"review code\"]\n     * ```\n     */\n    stateSchema?: StateSchema;\n    /**\n     * An optional schema for the context. It allows to pass in a typed context object into the agent\n     * invocation and allows to access it in hooks such as `prompt`, `preModelHook`, `postModelHook`, etc.\n     * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between\n     * agent invocations.\n     *\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [getWeather],\n     *   contextSchema: z.object({\n     *     capital: z.string(),\n     *   }),\n     *   prompt: (state, config) => {\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. The capital of France is ${config.context.capital}.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new SystemMessage(\"You are a helpful assistant.\"),\n     *     new HumanMessage(\"What is the capital of France?\"),\n     *   ],\n     * }, {\n     *   context: {\n     *     capital: \"Paris\",\n     *   },\n     * });\n     * ```\n     */\n    contextSchema?: ContextSchema;\n    /** An optional checkpoint saver to persist the agent's state. */\n    checkpointSaver?: BaseCheckpointSaver | boolean;\n    /** An optional checkpoint saver to persist the agent's state. Alias of \"checkpointSaver\". */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /** An optional list of node names to interrupt before running. */\n    interruptBefore?: N[] | All;\n    /** An optional list of node names to interrupt after running. */\n    interruptAfter?: N[] | All;\n    store?: BaseStore;\n    /**\n     * An optional schema for the final agent output.\n     *\n     * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.\n     * If not provided, `structuredResponse` will not be present in the output state.\n     *\n     * Can be passed in as:\n     *   - Zod schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: z.object({\n     *         capital: z.string(),\n     *       }),\n     *       // ...\n     *     });\n     *     ```\n     *   - JSON schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: {\n     *         type: \"json_schema\",\n     *         schema: {\n     *           type: \"object\",\n     *           properties: {\n     *             capital: { type: \"string\" },\n     *           },\n     *           required: [\"capital\"],\n     *         },\n     *       },\n     *       // ...\n     *     });\n     *     ```\n     *   - Create React Agent ResponseFormat\n     *     ```ts\n     *     import { providerStrategy, toolStrategy } from \"langchain\";\n     *     const agent = createAgent({\n     *       responseFormat: providerStrategy(\n     *         z.object({\n     *           capital: z.string(),\n     *         })\n     *       ),\n     *       // or\n     *       responseFormat: [\n     *         toolStrategy({ ... }),\n     *         toolStrategy({ ... }),\n     *       ]\n     *       // ...\n     *     });\n     *     ```\n     *\n     * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.\n     * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).\n     */\n    responseFormat?: ResponseFormatType;\n    /**\n     * An optional name for the agent.\n     */\n    name?: string;\n    /**\n     * An optional description for the agent.\n     * This can be used to describe the agent to the underlying supervisor LLM.\n     */\n    description?: string;\n    /**\n     * Use to specify how to expose the agent name to the underlying supervisor LLM.\n     *   - `undefined`: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.\n     *   - `\"inline\"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.\n     *       Example: `\"How can I help you\"` -> `\"<name>agent_name</name><content>How can I help you?</content>\"`\n     */\n    includeAgentName?: \"inline\" | undefined;\n    /**\n     * An optional node to add before the `agent` node (i.e., the node that calls the LLM).\n     * Useful for managing long message histories (e.g., message trimming, summarization, etc.).\n     */\n    preModelHook?: RunnableLike<ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<StateSchema>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>>;\n    /**\n     * An optional node to add after the `agent` node (i.e., the node that calls the LLM).\n     * Useful for implementing human-in-the-loop, guardrails, validation, or other post-processing.\n     */\n    postModelHook?: RunnableLike<ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<StateSchema>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>>;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n    /**\n     * Determines the version of the graph to create.\n     *\n     * Can be one of\n     * - `\"v1\"`: The tool node processes a single message. All tool calls in the message are\n     *           executed in parallel within the tool node.\n     * - `\"v2\"`: The tool node processes a single tool call. Tool calls are distributed across\n     *           multiple instances of the tool node using the Send API.\n     *\n     * @default `\"v2\"`\n     */\n    version?: \"v1\" | \"v2\";\n};\nexport type InternalAgentState<StructuredResponseType extends Record<string, unknown> | undefined = Record<string, unknown>> = {\n    messages: BaseMessage[];\n} & (StructuredResponseType extends ResponseFormatUndefined ? Record<string, never> : {\n    structuredResponse: StructuredResponseType;\n});\nexport type WithStateGraphNodes<K extends string, Graph> = Graph extends StateGraph<infer SD, infer S, infer U, infer N, infer I, infer O, infer C> ? StateGraph<SD, S, U, N | K, I, O, C> : never;\n/**\n * @deprecated likely to be removed in the next version of the agent\n */\ntype DynamicLLMFunction<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = (state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], runtime: AgentRuntime<ToAnnotationRoot<ContextSchema>[\"State\"]>) => Promise<LanguageModelLike> | LanguageModelLike;\nexport {};\n"],"mappings":"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"}

package/dist/agents/utils.cjs

@@ -1,6 +1,7 @@
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_errors = require('./errors.cjs');
 const require_constants = require('./constants.cjs');
+const require_model = require('./model.cjs');
 const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
 const __langchain_core_runnables = require_rolldown_runtime.__toESM(require("@langchain/core/runnables"));
 
@@ -22,11 +23,11 @@ const CONTENT_PATTERN = /<content>(.*?)<\/content>/s;
 * @internal
 */
 function _addInlineAgentName(message) {
-	const isAI = (0, __langchain_core_messages.isBaseMessage)(message) && ((0, __langchain_core_messages.isAIMessage)(message) || (0, __langchain_core_messages.isBaseMessageChunk)(message) && (0, __langchain_core_messages.isAIMessageChunk)(message));
-	if (!isAI || !message.name) return message;
+	if (!__langchain_core_messages.AIMessage.isInstance(message) || __langchain_core_messages.AIMessageChunk.isInstance(message)) return message;
+	if (!message.name) return message;
 	const { name } = message;
 	if (typeof message.content === "string") return new __langchain_core_messages.AIMessage({
-		...Object.keys(message.lc_kwargs ?? {}).length > 0 ? message.lc_kwargs : message,
+		...message.lc_kwargs,
 		content: `<name>${name}</name><content>${message.content}</content>`,
 		name: void 0
 	});
@@ -69,7 +70,7 @@ function _addInlineAgentName(message) {
 * @internal
 */
 function _removeInlineAgentName(message) {
-	if (!(0, __langchain_core_messages.isAIMessage)(message) || !message.content) return message;
+	if (!__langchain_core_messages.AIMessage.isInstance(message) || !message.content) return message;
 	let updatedContent = [];
 	let updatedName;
 	if (Array.isArray(message.content)) updatedContent = message.content.filter((block) => {
@@ -113,14 +114,8 @@ function _removeInlineAgentName(message) {
 function isClientTool(tool) {
 	return __langchain_core_runnables.Runnable.isRunnable(tool);
 }
-function isBaseChatModel(model) {
-	return "invoke" in model && typeof model.invoke === "function" && "_modelType" in model;
-}
-function isConfigurableModel(model) {
-	return typeof model === "object" && model != null && "_queuedMethodOperations" in model && "_model" in model && typeof model._model === "function";
-}
 function _isChatModelWithBindTools(llm) {
-	if (!isBaseChatModel(llm)) return false;
+	if (!require_model.isBaseChatModel(llm)) return false;
 	return "bindTools" in llm && typeof llm.bindTools === "function";
 }
 function getPromptRunnable(prompt) {
@@ -131,7 +126,7 @@ function getPromptRunnable(prompt) {
 		promptRunnable = __langchain_core_runnables.RunnableLambda.from((state) => {
 			return [systemMessage, ...state.messages ?? []];
 		}).withConfig({ runName: require_constants.PROMPT_RUNNABLE_NAME });
-	} else if ((0, __langchain_core_messages.isBaseMessage)(prompt) && prompt._getType() === "system") promptRunnable = __langchain_core_runnables.RunnableLambda.from((state) => [prompt, ...state.messages]).withConfig({ runName: require_constants.PROMPT_RUNNABLE_NAME });
+	} else if (__langchain_core_messages.SystemMessage.isInstance(prompt)) promptRunnable = __langchain_core_runnables.RunnableLambda.from((state) => [prompt, ...state.messages]).withConfig({ runName: require_constants.PROMPT_RUNNABLE_NAME });
 	else if (typeof prompt === "function") promptRunnable = __langchain_core_runnables.RunnableLambda.from(prompt).withConfig({ runName: require_constants.PROMPT_RUNNABLE_NAME });
 	else if (__langchain_core_runnables.Runnable.isRunnable(prompt)) promptRunnable = prompt;
 	else throw new Error(`Got unexpected type for 'prompt': ${typeof prompt}`);
@@ -165,12 +160,12 @@ const _simpleBindTools = (llm, toolClasses, options = {}) => {
 async function bindTools(llm, toolClasses, options = {}) {
 	const model = _simpleBindTools(llm, toolClasses, options);
 	if (model) return model;
-	if (isConfigurableModel(llm)) {
+	if (require_model.isConfigurableModel(llm)) {
 		const model$1 = _simpleBindTools(await llm._model(), toolClasses, options);
 		if (model$1) return model$1;
 	}
 	if (__langchain_core_runnables.RunnableSequence.isRunnableSequence(llm)) {
-		const modelStep = llm.steps.findIndex((step) => __langchain_core_runnables.RunnableBinding.isRunnableBinding(step) || isBaseChatModel(step) || isConfigurableModel(step));
+		const modelStep = llm.steps.findIndex((step) => __langchain_core_runnables.RunnableBinding.isRunnableBinding(step) || require_model.isBaseChatModel(step) || require_model.isConfigurableModel(step));
 		if (modelStep >= 0) {
 			const model$1 = _simpleBindTools(llm.steps[modelStep], toolClasses, options);
 			if (model$1) {
@@ -201,7 +196,7 @@ function validateLLMHasNoBoundTools(llm) {
 	/**
 	* If model is configurable, get the underlying model
 	*/
-	if (isConfigurableModel(model))
+	if (require_model.isConfigurableModel(model))
  /**
 	* Can't validate async model retrieval in constructor
 	*/
@@ -227,19 +222,7 @@ function validateLLMHasNoBoundTools(llm) {
 */
 function hasToolCalls(messages) {
 	const lastMessage = messages.at(-1);
-	return Boolean(lastMessage instanceof __langchain_core_messages.AIMessage && lastMessage.tool_calls && lastMessage.tool_calls.length > 0);
-}
-const CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT = ["ChatOpenAI", "FakeToolCallingModel"];
-/**
-* 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 (!isBaseChatModel(model)) return false;
-	const chatModelClass = model.getName();
-	if (CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.includes(chatModelClass) && (chatModelClass === "ChatOpenAI" && "model" in model && typeof model.model === "string" && model.model.startsWith("gpt-4") || chatModelClass === "FakeToolCallingModel" && "structuredResponse" in model)) return true;
-	return false;
+	return Boolean(__langchain_core_messages.AIMessage.isInstance(lastMessage) && lastMessage.tool_calls && lastMessage.tool_calls.length > 0);
 }
 
 //#endregion
@@ -247,7 +230,6 @@ exports._addInlineAgentName = _addInlineAgentName;
 exports._removeInlineAgentName = _removeInlineAgentName;
 exports.bindTools = bindTools;
 exports.getPromptRunnable = getPromptRunnable;
-exports.hasSupportForJsonSchemaOutput = hasSupportForJsonSchemaOutput;
 exports.hasToolCalls = hasToolCalls;
 exports.isClientTool = isClientTool;
 exports.validateLLMHasNoBoundTools = validateLLMHasNoBoundTools;

package/dist/agents/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":["message: T","AIMessage","updatedContent: MessageContent","updatedName: string | undefined","tool: ClientTool | ServerTool","Runnable","model: LanguageModelLike","model: unknown","llm: LanguageModelLike","prompt?: Prompt","promptRunnable: Runnable","RunnableLambda","state: typeof MessagesAnnotation.State","PROMPT_RUNNABLE_NAME","SystemMessage","toolClasses: (ClientTool | ServerTool)[]","options: Partial<BaseChatModelCallOptions>","RunnableBinding","model","RunnableSequence","nextSteps: unknown[]","step: RunnableLike","MultipleToolsBoundError","messages: BaseMessage[]"],"sources":["../../src/agents/utils.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\nimport {\n  AIMessage,\n  BaseMessage,\n  BaseMessageLike,\n  MessageContent,\n  SystemMessage,\n  AIMessageChunk,\n  isAIMessage,\n  isAIMessageChunk,\n  isBaseMessage,\n  isBaseMessageChunk,\n} from \"@langchain/core/messages\";\nimport { MessagesAnnotation } from \"@langchain/langgraph\";\nimport {\n  BaseChatModel,\n  type BindToolsInput,\n  type BaseChatModelCallOptions,\n} from \"@langchain/core/language_models/chat_models\";\nimport {\n  LanguageModelLike,\n  BaseLanguageModelInput,\n} from \"@langchain/core/language_models/base\";\nimport {\n  Runnable,\n  RunnableLike,\n  RunnableConfig,\n  RunnableLambda,\n  RunnableSequence,\n  RunnableBinding,\n} from \"@langchain/core/runnables\";\n\nimport { MultipleToolsBoundError } from \"./errors.js\";\nimport { PROMPT_RUNNABLE_NAME } from \"./constants.js\";\nimport {\n  ServerTool,\n  ClientTool,\n  ConfigurableModelInterface,\n  Prompt,\n} from \"./types.js\";\n\nconst NAME_PATTERN = /<name>(.*?)<\\/name>/s;\nconst CONTENT_PATTERN = /<content>(.*?)<\\/content>/s;\n\nexport type AgentNameMode = \"inline\";\n\n/**\n * Attach formatted agent names to the messages passed to and from a language model.\n *\n * This is useful for making a message history with multiple agents more coherent.\n *\n * NOTE: agent name is consumed from the message.name field.\n * If you're using an agent built with createAgent, name is automatically set.\n * If you're building a custom agent, make sure to set the name on the AI message returned by the LLM.\n *\n * @param message - Message to add agent name formatting to\n * @returns Message with agent name formatting\n *\n * @internal\n */\nexport function _addInlineAgentName<T extends BaseMessageLike>(\n  message: T\n): T | AIMessage {\n  const isAI =\n    isBaseMessage(message) &&\n    (isAIMessage(message) ||\n      (isBaseMessageChunk(message) && isAIMessageChunk(message)));\n\n  if (!isAI || !message.name) {\n    return message;\n  }\n\n  const { name } = message;\n\n  if (typeof message.content === \"string\") {\n    return new AIMessage({\n      ...(Object.keys(message.lc_kwargs ?? {}).length > 0\n        ? message.lc_kwargs\n        : message),\n      content: `<name>${name}</name><content>${message.content}</content>`,\n      name: undefined,\n    });\n  }\n\n  const updatedContent = [];\n  let textBlockCount = 0;\n\n  for (const contentBlock of message.content) {\n    if (typeof contentBlock === \"string\") {\n      textBlockCount += 1;\n      updatedContent.push(\n        `<name>${name}</name><content>${contentBlock}</content>`\n      );\n    } else if (\n      typeof contentBlock === \"object\" &&\n      \"type\" in contentBlock &&\n      contentBlock.type === \"text\"\n    ) {\n      textBlockCount += 1;\n      updatedContent.push({\n        ...contentBlock,\n        text: `<name>${name}</name><content>${contentBlock.text}</content>`,\n      });\n    } else {\n      updatedContent.push(contentBlock);\n    }\n  }\n\n  if (!textBlockCount) {\n    updatedContent.unshift({\n      type: \"text\",\n      text: `<name>${name}</name><content></content>`,\n    });\n  }\n  return new AIMessage({\n    ...message.lc_kwargs,\n    content: updatedContent as MessageContent,\n    name: undefined,\n  });\n}\n\n/**\n * Remove explicit name and content XML tags from the AI message content.\n *\n * Examples:\n *\n * @example\n * ```typescript\n * removeInlineAgentName(new AIMessage({ content: \"<name>assistant</name><content>Hello</content>\", name: \"assistant\" }))\n * // AIMessage with content: \"Hello\"\n *\n * removeInlineAgentName(new AIMessage({ content: [{type: \"text\", text: \"<name>assistant</name><content>Hello</content>\"}], name: \"assistant\" }))\n * // AIMessage with content: [{type: \"text\", text: \"Hello\"}]\n * ```\n *\n * @internal\n */\nexport function _removeInlineAgentName<T extends BaseMessage>(message: T): T {\n  if (!isAIMessage(message) || !message.content) {\n    return message;\n  }\n\n  let updatedContent: MessageContent = [];\n  let updatedName: string | undefined;\n\n  if (Array.isArray(message.content)) {\n    updatedContent = message.content\n      .filter((block) => {\n        if (block.type === \"text\" && typeof block.text === \"string\") {\n          const nameMatch = block.text.match(NAME_PATTERN);\n          const contentMatch = block.text.match(CONTENT_PATTERN);\n          // don't include empty content blocks that were added because there was no text block to modify\n          if (nameMatch && (!contentMatch || contentMatch[1] === \"\")) {\n            // capture name from text block\n            // eslint-disable-next-line prefer-destructuring\n            updatedName = nameMatch[1];\n            return false;\n          }\n          return true;\n        }\n        return true;\n      })\n      .map((block) => {\n        if (block.type === \"text\" && typeof block.text === \"string\") {\n          const nameMatch = block.text.match(NAME_PATTERN);\n          const contentMatch = block.text.match(CONTENT_PATTERN);\n\n          if (!nameMatch || !contentMatch) {\n            return block;\n          }\n\n          // capture name from text block\n          // eslint-disable-next-line prefer-destructuring\n          updatedName = nameMatch[1];\n\n          return {\n            ...block,\n            text: contentMatch[1],\n          };\n        }\n        return block;\n      });\n  } else {\n    const content = message.content as string;\n    const nameMatch = content.match(NAME_PATTERN);\n    const contentMatch = content.match(CONTENT_PATTERN);\n\n    if (!nameMatch || !contentMatch) {\n      return message;\n    }\n\n    // eslint-disable-next-line prefer-destructuring\n    updatedName = nameMatch[1];\n    // eslint-disable-next-line prefer-destructuring\n    updatedContent = contentMatch[1];\n  }\n\n  return new AIMessage({\n    ...(Object.keys(message.lc_kwargs ?? {}).length > 0\n      ? message.lc_kwargs\n      : message),\n    content: updatedContent,\n    name: updatedName,\n  }) as T;\n}\n\nexport function isClientTool(\n  tool: ClientTool | ServerTool\n): tool is ClientTool {\n  return Runnable.isRunnable(tool);\n}\n\nexport function isBaseChatModel(\n  model: LanguageModelLike\n): model is BaseChatModel {\n  return (\n    \"invoke\" in model &&\n    typeof model.invoke === \"function\" &&\n    \"_modelType\" in model\n  );\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isConfigurableModel(\n  model: unknown\n): model is ConfigurableModelInterface {\n  return (\n    typeof model === \"object\" &&\n    model != null &&\n    \"_queuedMethodOperations\" in model &&\n    \"_model\" in model &&\n    typeof model._model === \"function\"\n  );\n}\n\nfunction _isChatModelWithBindTools(\n  llm: LanguageModelLike\n): llm is BaseChatModel & Required<Pick<BaseChatModel, \"bindTools\">> {\n  if (!isBaseChatModel(llm)) return false;\n  return \"bindTools\" in llm && typeof llm.bindTools === \"function\";\n}\n\nexport function getPromptRunnable(prompt?: Prompt): Runnable {\n  let promptRunnable: Runnable;\n\n  if (prompt == null) {\n    promptRunnable = RunnableLambda.from(\n      (state: typeof MessagesAnnotation.State) => state.messages\n    ).withConfig({ runName: PROMPT_RUNNABLE_NAME });\n  } else if (typeof prompt === \"string\") {\n    const systemMessage = new SystemMessage(prompt);\n    promptRunnable = RunnableLambda.from(\n      (state: typeof MessagesAnnotation.State) => {\n        return [systemMessage, ...(state.messages ?? [])];\n      }\n    ).withConfig({ runName: PROMPT_RUNNABLE_NAME });\n  } else if (isBaseMessage(prompt) && prompt._getType() === \"system\") {\n    promptRunnable = RunnableLambda.from(\n      (state: typeof MessagesAnnotation.State) => [prompt, ...state.messages]\n    ).withConfig({ runName: PROMPT_RUNNABLE_NAME });\n  } else if (typeof prompt === \"function\") {\n    promptRunnable = RunnableLambda.from(prompt).withConfig({\n      runName: PROMPT_RUNNABLE_NAME,\n    });\n  } else if (Runnable.isRunnable(prompt)) {\n    promptRunnable = prompt;\n  } else {\n    throw new Error(`Got unexpected type for 'prompt': ${typeof prompt}`);\n  }\n\n  return promptRunnable;\n}\n\nexport async function shouldBindTools(\n  llm: LanguageModelLike,\n  tools: (ClientTool | ServerTool)[]\n): Promise<boolean> {\n  // If model is a RunnableSequence, find a RunnableBinding or BaseChatModel in its steps\n  let model = llm;\n  if (RunnableSequence.isRunnableSequence(model)) {\n    model =\n      model.steps.find(\n        (step) =>\n          RunnableBinding.isRunnableBinding(step) ||\n          isBaseChatModel(step) ||\n          isConfigurableModel(step)\n      ) || model;\n  }\n\n  if (isConfigurableModel(model)) {\n    model = await model._model();\n  }\n\n  // If not a RunnableBinding, we should bind tools\n  if (!RunnableBinding.isRunnableBinding(model)) {\n    return true;\n  }\n\n  let boundTools = (() => {\n    // check if model.kwargs contain the tools key\n    if (\n      model.kwargs != null &&\n      typeof model.kwargs === \"object\" &&\n      \"tools\" in model.kwargs &&\n      Array.isArray(model.kwargs.tools)\n    ) {\n      return (model.kwargs.tools ?? null) as BindToolsInput[] | null;\n    }\n\n    // Some models can bind the tools via `withConfig()` instead of `bind()`\n    if (\n      model.config != null &&\n      typeof model.config === \"object\" &&\n      \"tools\" in model.config &&\n      Array.isArray(model.config.tools)\n    ) {\n      return (model.config.tools ?? null) as BindToolsInput[] | null;\n    }\n\n    return null;\n  })();\n\n  // google-style\n  if (\n    boundTools != null &&\n    boundTools.length === 1 &&\n    \"functionDeclarations\" in boundTools[0]\n  ) {\n    boundTools = boundTools[0].functionDeclarations;\n  }\n\n  // If no tools in kwargs, we should bind tools\n  if (boundTools == null) return true;\n\n  // Check if tools count matches\n  if (tools.length !== boundTools.length) {\n    throw new Error(\n      \"Number of tools in the model.bindTools() and tools passed to createAgent must match\"\n    );\n  }\n\n  const toolNames = new Set<string>(\n    tools.flatMap((tool) => (isClientTool(tool) ? tool.name : []))\n  );\n\n  const boundToolNames = new Set<string>();\n\n  for (const boundTool of boundTools) {\n    let boundToolName: string | undefined;\n\n    // OpenAI-style tool\n    if (\"type\" in boundTool && boundTool.type === \"function\") {\n      boundToolName = boundTool.function.name;\n    }\n    // Anthropic or Google-style tool\n    else if (\"name\" in boundTool) {\n      boundToolName = boundTool.name;\n    }\n    // Bedrock-style tool\n    else if (\"toolSpec\" in boundTool && \"name\" in boundTool.toolSpec) {\n      boundToolName = boundTool.toolSpec.name;\n    }\n    // unknown tool type so we'll ignore it\n    else {\n      continue;\n    }\n\n    if (boundToolName) {\n      boundToolNames.add(boundToolName);\n    }\n  }\n\n  const missingTools = [...toolNames].filter((x) => !boundToolNames.has(x));\n  if (missingTools.length > 0) {\n    throw new Error(\n      `Missing tools '${missingTools}' in the model.bindTools().` +\n        `Tools in the model.bindTools() must match the tools passed to createAgent.`\n    );\n  }\n\n  return false;\n}\n\nconst _simpleBindTools = (\n  llm: LanguageModelLike,\n  toolClasses: (ClientTool | ServerTool)[],\n  options: Partial<BaseChatModelCallOptions> = {}\n) => {\n  if (_isChatModelWithBindTools(llm)) {\n    return llm.bindTools(toolClasses, options);\n  }\n\n  if (\n    RunnableBinding.isRunnableBinding(llm) &&\n    _isChatModelWithBindTools(llm.bound)\n  ) {\n    const newBound = llm.bound.bindTools(toolClasses, options);\n\n    if (RunnableBinding.isRunnableBinding(newBound)) {\n      return new RunnableBinding({\n        bound: newBound.bound,\n        config: { ...llm.config, ...newBound.config },\n        kwargs: { ...llm.kwargs, ...newBound.kwargs },\n        configFactories: newBound.configFactories ?? llm.configFactories,\n      });\n    }\n\n    return new RunnableBinding({\n      bound: newBound,\n      config: llm.config,\n      kwargs: llm.kwargs,\n      configFactories: llm.configFactories,\n    });\n  }\n\n  return null;\n};\n\nexport async function bindTools(\n  llm: LanguageModelLike,\n  toolClasses: (ClientTool | ServerTool)[],\n  options: Partial<BaseChatModelCallOptions> = {}\n): Promise<\n  | RunnableSequence<any, any>\n  | RunnableBinding<any, any, RunnableConfig<Record<string, any>>>\n  | Runnable<BaseLanguageModelInput, AIMessageChunk, BaseChatModelCallOptions>\n> {\n  const model = _simpleBindTools(llm, toolClasses, options);\n  if (model) return model;\n\n  if (isConfigurableModel(llm)) {\n    const model = _simpleBindTools(await llm._model(), toolClasses, options);\n    if (model) return model;\n  }\n\n  if (RunnableSequence.isRunnableSequence(llm)) {\n    const modelStep = llm.steps.findIndex(\n      (step) =>\n        RunnableBinding.isRunnableBinding(step) ||\n        isBaseChatModel(step) ||\n        isConfigurableModel(step)\n    );\n\n    if (modelStep >= 0) {\n      const model = _simpleBindTools(\n        llm.steps[modelStep],\n        toolClasses,\n        options\n      );\n      if (model) {\n        const nextSteps: unknown[] = llm.steps.slice();\n        nextSteps.splice(modelStep, 1, model);\n\n        return RunnableSequence.from(\n          nextSteps as [RunnableLike, ...RunnableLike[], RunnableLike]\n        );\n      }\n    }\n  }\n\n  throw new Error(`llm ${llm} must define bindTools method.`);\n}\n\n/**\n * Check if the LLM already has bound tools and throw if it does.\n *\n * @param llm - The LLM to check.\n * @returns void\n */\nexport function validateLLMHasNoBoundTools(llm: LanguageModelLike): void {\n  /**\n   * If llm is a function, we can't validate until runtime, so skip\n   */\n  if (typeof llm === \"function\") {\n    return;\n  }\n\n  let model = llm;\n\n  /**\n   * If model is a RunnableSequence, find a RunnableBinding in its steps\n   */\n  if (RunnableSequence.isRunnableSequence(model)) {\n    model =\n      model.steps.find((step: RunnableLike) =>\n        RunnableBinding.isRunnableBinding(step)\n      ) || model;\n  }\n\n  /**\n   * If model is configurable, get the underlying model\n   */\n  if (isConfigurableModel(model)) {\n    /**\n     * Can't validate async model retrieval in constructor\n     */\n    return;\n  }\n\n  /**\n   * Check if model is a RunnableBinding with bound tools\n   */\n  if (RunnableBinding.isRunnableBinding(model)) {\n    const hasToolsInKwargs =\n      model.kwargs != null &&\n      typeof model.kwargs === \"object\" &&\n      \"tools\" in model.kwargs &&\n      Array.isArray(model.kwargs.tools) &&\n      model.kwargs.tools.length > 0;\n\n    const hasToolsInConfig =\n      model.config != null &&\n      typeof model.config === \"object\" &&\n      \"tools\" in model.config &&\n      Array.isArray(model.config.tools) &&\n      model.config.tools.length > 0;\n\n    if (hasToolsInKwargs || hasToolsInConfig) {\n      throw new MultipleToolsBoundError();\n    }\n  }\n\n  /**\n   * Also check if model has tools property directly (e.g., FakeToolCallingModel)\n   */\n  if (\n    \"tools\" in model &&\n    model.tools !== undefined &&\n    Array.isArray(model.tools) &&\n    model.tools.length > 0\n  ) {\n    throw new MultipleToolsBoundError();\n  }\n}\n\n/**\n * Check if the last message in the messages array has tool calls.\n *\n * @param messages - The messages to check.\n * @returns True if the last message has tool calls, false otherwise.\n */\nexport function hasToolCalls(messages: BaseMessage[]): boolean {\n  const lastMessage = messages.at(-1);\n  return Boolean(\n    lastMessage instanceof AIMessage &&\n      lastMessage.tool_calls &&\n      lastMessage.tool_calls.length > 0\n  );\n}\n\n/**\n * Check if the model name supports structured output\n * @param modelName - The name of the model\n * @returns True if the model supports structured output, false otherwise\n */\nexport function hasSupportForStructuredOutput(modelName?: string): boolean {\n  return (\n    modelName?.startsWith(\"gpt-4\") || modelName?.startsWith(\"gpt-5\") || false\n  );\n}\n\nconst CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT = [\n  \"ChatOpenAI\",\n  \"FakeToolCallingModel\",\n];\n\n/**\n * Identifies the models that support JSON schema output\n * @param model - The model to check\n * @returns True if the model supports JSON schema output, false otherwise\n */\nexport function hasSupportForJsonSchemaOutput(\n  model: LanguageModelLike\n): boolean {\n  if (!isBaseChatModel(model)) {\n    return false;\n  }\n\n  const chatModelClass = model.getName();\n  if (\n    CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.includes(chatModelClass) &&\n    ((chatModelClass === \"ChatOpenAI\" &&\n      /**\n       * OpenAI models\n       */\n      \"model\" in model &&\n      typeof model.model === \"string\" &&\n      model.model.startsWith(\"gpt-4\")) ||\n      /**\n       * for testing purposes only\n       */\n      (chatModelClass === \"FakeToolCallingModel\" &&\n        \"structuredResponse\" in model))\n  ) {\n    return true;\n  }\n\n  return false;\n}\n"],"mappings":"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"}
+{"version":3,"file":"utils.cjs","names":["message: T","AIMessage","AIMessageChunk","updatedContent: MessageContent","updatedName: string | undefined","tool: ClientTool | ServerTool","Runnable","llm: LanguageModelLike","isBaseChatModel","prompt?: Prompt","promptRunnable: Runnable","RunnableLambda","state: typeof MessagesAnnotation.State","PROMPT_RUNNABLE_NAME","SystemMessage","toolClasses: (ClientTool | ServerTool)[]","options: Partial<BaseChatModelCallOptions>","RunnableBinding","isConfigurableModel","model","RunnableSequence","nextSteps: unknown[]","step: RunnableLike","MultipleToolsBoundError","messages: BaseMessage[]"],"sources":["../../src/agents/utils.ts"],"sourcesContent":["import {\n  AIMessage,\n  AIMessageChunk,\n  BaseMessage,\n  BaseMessageLike,\n  SystemMessage,\n  MessageContent,\n} from \"@langchain/core/messages\";\nimport { MessagesAnnotation } from \"@langchain/langgraph\";\nimport {\n  BaseChatModel,\n  type BindToolsInput,\n  type BaseChatModelCallOptions,\n} from \"@langchain/core/language_models/chat_models\";\nimport {\n  LanguageModelLike,\n  BaseLanguageModelInput,\n} from \"@langchain/core/language_models/base\";\nimport {\n  Runnable,\n  RunnableLike,\n  RunnableConfig,\n  RunnableLambda,\n  RunnableSequence,\n  RunnableBinding,\n} from \"@langchain/core/runnables\";\n\nimport { MultipleToolsBoundError } from \"./errors.js\";\nimport { PROMPT_RUNNABLE_NAME } from \"./constants.js\";\nimport { ServerTool, ClientTool, Prompt } from \"./types.js\";\nimport { isBaseChatModel, isConfigurableModel } from \"./model.js\";\n\nconst NAME_PATTERN = /<name>(.*?)<\\/name>/s;\nconst CONTENT_PATTERN = /<content>(.*?)<\\/content>/s;\n\nexport type AgentNameMode = \"inline\";\n\n/**\n * Attach formatted agent names to the messages passed to and from a language model.\n *\n * This is useful for making a message history with multiple agents more coherent.\n *\n * NOTE: agent name is consumed from the message.name field.\n * If you're using an agent built with createAgent, name is automatically set.\n * If you're building a custom agent, make sure to set the name on the AI message returned by the LLM.\n *\n * @param message - Message to add agent name formatting to\n * @returns Message with agent name formatting\n *\n * @internal\n */\nexport function _addInlineAgentName<T extends BaseMessageLike>(\n  message: T\n): T | AIMessage {\n  if (!AIMessage.isInstance(message) || AIMessageChunk.isInstance(message)) {\n    return message;\n  }\n\n  if (!message.name) {\n    return message;\n  }\n\n  const { name } = message;\n\n  if (typeof message.content === \"string\") {\n    return new AIMessage({\n      ...message.lc_kwargs,\n      content: `<name>${name}</name><content>${message.content}</content>`,\n      name: undefined,\n    });\n  }\n\n  const updatedContent = [];\n  let textBlockCount = 0;\n\n  for (const contentBlock of message.content) {\n    if (typeof contentBlock === \"string\") {\n      textBlockCount += 1;\n      updatedContent.push(\n        `<name>${name}</name><content>${contentBlock}</content>`\n      );\n    } else if (\n      typeof contentBlock === \"object\" &&\n      \"type\" in contentBlock &&\n      contentBlock.type === \"text\"\n    ) {\n      textBlockCount += 1;\n      updatedContent.push({\n        ...contentBlock,\n        text: `<name>${name}</name><content>${contentBlock.text}</content>`,\n      });\n    } else {\n      updatedContent.push(contentBlock);\n    }\n  }\n\n  if (!textBlockCount) {\n    updatedContent.unshift({\n      type: \"text\",\n      text: `<name>${name}</name><content></content>`,\n    });\n  }\n  return new AIMessage({\n    ...message.lc_kwargs,\n    content: updatedContent as MessageContent,\n    name: undefined,\n  });\n}\n\n/**\n * Remove explicit name and content XML tags from the AI message content.\n *\n * Examples:\n *\n * @example\n * ```typescript\n * removeInlineAgentName(new AIMessage({ content: \"<name>assistant</name><content>Hello</content>\", name: \"assistant\" }))\n * // AIMessage with content: \"Hello\"\n *\n * removeInlineAgentName(new AIMessage({ content: [{type: \"text\", text: \"<name>assistant</name><content>Hello</content>\"}], name: \"assistant\" }))\n * // AIMessage with content: [{type: \"text\", text: \"Hello\"}]\n * ```\n *\n * @internal\n */\nexport function _removeInlineAgentName<T extends BaseMessage>(message: T): T {\n  if (!AIMessage.isInstance(message) || !message.content) {\n    return message;\n  }\n\n  let updatedContent: MessageContent = [];\n  let updatedName: string | undefined;\n\n  if (Array.isArray(message.content)) {\n    updatedContent = message.content\n      .filter((block) => {\n        if (block.type === \"text\" && typeof block.text === \"string\") {\n          const nameMatch = block.text.match(NAME_PATTERN);\n          const contentMatch = block.text.match(CONTENT_PATTERN);\n          // don't include empty content blocks that were added because there was no text block to modify\n          if (nameMatch && (!contentMatch || contentMatch[1] === \"\")) {\n            // capture name from text block\n            updatedName = nameMatch[1];\n            return false;\n          }\n          return true;\n        }\n        return true;\n      })\n      .map((block) => {\n        if (block.type === \"text\" && typeof block.text === \"string\") {\n          const nameMatch = block.text.match(NAME_PATTERN);\n          const contentMatch = block.text.match(CONTENT_PATTERN);\n\n          if (!nameMatch || !contentMatch) {\n            return block;\n          }\n\n          // capture name from text block\n          updatedName = nameMatch[1];\n\n          return {\n            ...block,\n            text: contentMatch[1],\n          };\n        }\n        return block;\n      });\n  } else {\n    const content = message.content as string;\n    const nameMatch = content.match(NAME_PATTERN);\n    const contentMatch = content.match(CONTENT_PATTERN);\n\n    if (!nameMatch || !contentMatch) {\n      return message;\n    }\n\n    updatedName = nameMatch[1];\n    updatedContent = contentMatch[1];\n  }\n\n  return new AIMessage({\n    ...(Object.keys(message.lc_kwargs ?? {}).length > 0\n      ? message.lc_kwargs\n      : message),\n    content: updatedContent,\n    name: updatedName,\n  }) as T;\n}\n\nexport function isClientTool(\n  tool: ClientTool | ServerTool\n): tool is ClientTool {\n  return Runnable.isRunnable(tool);\n}\n\nfunction _isChatModelWithBindTools(\n  llm: LanguageModelLike\n): llm is BaseChatModel & Required<Pick<BaseChatModel, \"bindTools\">> {\n  if (!isBaseChatModel(llm)) return false;\n  return \"bindTools\" in llm && typeof llm.bindTools === \"function\";\n}\n\nexport function getPromptRunnable(prompt?: Prompt): Runnable {\n  let promptRunnable: Runnable;\n\n  if (prompt == null) {\n    promptRunnable = RunnableLambda.from(\n      (state: typeof MessagesAnnotation.State) => state.messages\n    ).withConfig({ runName: PROMPT_RUNNABLE_NAME });\n  } else if (typeof prompt === \"string\") {\n    const systemMessage = new SystemMessage(prompt);\n    promptRunnable = RunnableLambda.from(\n      (state: typeof MessagesAnnotation.State) => {\n        return [systemMessage, ...(state.messages ?? [])];\n      }\n    ).withConfig({ runName: PROMPT_RUNNABLE_NAME });\n  } else if (SystemMessage.isInstance(prompt)) {\n    promptRunnable = RunnableLambda.from(\n      (state: typeof MessagesAnnotation.State) => [prompt, ...state.messages]\n    ).withConfig({ runName: PROMPT_RUNNABLE_NAME });\n  } else if (typeof prompt === \"function\") {\n    promptRunnable = RunnableLambda.from(prompt).withConfig({\n      runName: PROMPT_RUNNABLE_NAME,\n    });\n  } else if (Runnable.isRunnable(prompt)) {\n    promptRunnable = prompt;\n  } else {\n    throw new Error(`Got unexpected type for 'prompt': ${typeof prompt}`);\n  }\n\n  return promptRunnable;\n}\n\nexport async function shouldBindTools(\n  llm: LanguageModelLike,\n  tools: (ClientTool | ServerTool)[]\n): Promise<boolean> {\n  // If model is a RunnableSequence, find a RunnableBinding or BaseChatModel in its steps\n  let model = llm;\n  if (RunnableSequence.isRunnableSequence(model)) {\n    model =\n      model.steps.find(\n        (step) =>\n          RunnableBinding.isRunnableBinding(step) ||\n          isBaseChatModel(step) ||\n          isConfigurableModel(step)\n      ) || model;\n  }\n\n  if (isConfigurableModel(model)) {\n    model = await model._model();\n  }\n\n  // If not a RunnableBinding, we should bind tools\n  if (!RunnableBinding.isRunnableBinding(model)) {\n    return true;\n  }\n\n  let boundTools = (() => {\n    // check if model.kwargs contain the tools key\n    if (\n      model.kwargs != null &&\n      typeof model.kwargs === \"object\" &&\n      \"tools\" in model.kwargs &&\n      Array.isArray(model.kwargs.tools)\n    ) {\n      return (model.kwargs.tools ?? null) as BindToolsInput[] | null;\n    }\n\n    // Some models can bind the tools via `withConfig()` instead of `bind()`\n    if (\n      model.config != null &&\n      typeof model.config === \"object\" &&\n      \"tools\" in model.config &&\n      Array.isArray(model.config.tools)\n    ) {\n      return (model.config.tools ?? null) as BindToolsInput[] | null;\n    }\n\n    return null;\n  })();\n\n  // google-style\n  if (\n    boundTools != null &&\n    boundTools.length === 1 &&\n    \"functionDeclarations\" in boundTools[0]\n  ) {\n    boundTools = boundTools[0].functionDeclarations;\n  }\n\n  // If no tools in kwargs, we should bind tools\n  if (boundTools == null) return true;\n\n  // Check if tools count matches\n  if (tools.length !== boundTools.length) {\n    throw new Error(\n      \"Number of tools in the model.bindTools() and tools passed to createAgent must match\"\n    );\n  }\n\n  const toolNames = new Set<string>(\n    tools.flatMap((tool) => (isClientTool(tool) ? tool.name : []))\n  );\n\n  const boundToolNames = new Set<string>();\n\n  for (const boundTool of boundTools) {\n    let boundToolName: string | undefined;\n\n    // OpenAI-style tool\n    if (\"type\" in boundTool && boundTool.type === \"function\") {\n      boundToolName = boundTool.function.name;\n    }\n    // Anthropic or Google-style tool\n    else if (\"name\" in boundTool) {\n      boundToolName = boundTool.name;\n    }\n    // Bedrock-style tool\n    else if (\"toolSpec\" in boundTool && \"name\" in boundTool.toolSpec) {\n      boundToolName = boundTool.toolSpec.name;\n    }\n    // unknown tool type so we'll ignore it\n    else {\n      continue;\n    }\n\n    if (boundToolName) {\n      boundToolNames.add(boundToolName);\n    }\n  }\n\n  const missingTools = [...toolNames].filter((x) => !boundToolNames.has(x));\n  if (missingTools.length > 0) {\n    throw new Error(\n      `Missing tools '${missingTools}' in the model.bindTools().` +\n        `Tools in the model.bindTools() must match the tools passed to createAgent.`\n    );\n  }\n\n  return false;\n}\n\nconst _simpleBindTools = (\n  llm: LanguageModelLike,\n  toolClasses: (ClientTool | ServerTool)[],\n  options: Partial<BaseChatModelCallOptions> = {}\n) => {\n  if (_isChatModelWithBindTools(llm)) {\n    return llm.bindTools(toolClasses, options);\n  }\n\n  if (\n    RunnableBinding.isRunnableBinding(llm) &&\n    _isChatModelWithBindTools(llm.bound)\n  ) {\n    const newBound = llm.bound.bindTools(toolClasses, options);\n\n    if (RunnableBinding.isRunnableBinding(newBound)) {\n      return new RunnableBinding({\n        bound: newBound.bound,\n        config: { ...llm.config, ...newBound.config },\n        kwargs: { ...llm.kwargs, ...newBound.kwargs },\n        configFactories: newBound.configFactories ?? llm.configFactories,\n      });\n    }\n\n    return new RunnableBinding({\n      bound: newBound,\n      config: llm.config,\n      kwargs: llm.kwargs,\n      configFactories: llm.configFactories,\n    });\n  }\n\n  return null;\n};\n\nexport async function bindTools(\n  llm: LanguageModelLike,\n  toolClasses: (ClientTool | ServerTool)[],\n  options: Partial<BaseChatModelCallOptions> = {}\n): Promise<\n  | RunnableSequence<unknown, unknown>\n  | RunnableBinding<unknown, unknown, RunnableConfig<Record<string, unknown>>>\n  | Runnable<BaseLanguageModelInput, AIMessageChunk, BaseChatModelCallOptions>\n> {\n  const model = _simpleBindTools(llm, toolClasses, options);\n  if (model) return model;\n\n  if (isConfigurableModel(llm)) {\n    const model = _simpleBindTools(await llm._model(), toolClasses, options);\n    if (model) return model;\n  }\n\n  if (RunnableSequence.isRunnableSequence(llm)) {\n    const modelStep = llm.steps.findIndex(\n      (step) =>\n        RunnableBinding.isRunnableBinding(step) ||\n        isBaseChatModel(step) ||\n        isConfigurableModel(step)\n    );\n\n    if (modelStep >= 0) {\n      const model = _simpleBindTools(\n        llm.steps[modelStep],\n        toolClasses,\n        options\n      );\n      if (model) {\n        const nextSteps: unknown[] = llm.steps.slice();\n        nextSteps.splice(modelStep, 1, model);\n\n        return RunnableSequence.from(\n          nextSteps as [RunnableLike, ...RunnableLike[], RunnableLike]\n        );\n      }\n    }\n  }\n\n  throw new Error(`llm ${llm} must define bindTools method.`);\n}\n\n/**\n * Check if the LLM already has bound tools and throw if it does.\n *\n * @param llm - The LLM to check.\n * @returns void\n */\nexport function validateLLMHasNoBoundTools(llm: LanguageModelLike): void {\n  /**\n   * If llm is a function, we can't validate until runtime, so skip\n   */\n  if (typeof llm === \"function\") {\n    return;\n  }\n\n  let model = llm;\n\n  /**\n   * If model is a RunnableSequence, find a RunnableBinding in its steps\n   */\n  if (RunnableSequence.isRunnableSequence(model)) {\n    model =\n      model.steps.find((step: RunnableLike) =>\n        RunnableBinding.isRunnableBinding(step)\n      ) || model;\n  }\n\n  /**\n   * If model is configurable, get the underlying model\n   */\n  if (isConfigurableModel(model)) {\n    /**\n     * Can't validate async model retrieval in constructor\n     */\n    return;\n  }\n\n  /**\n   * Check if model is a RunnableBinding with bound tools\n   */\n  if (RunnableBinding.isRunnableBinding(model)) {\n    const hasToolsInKwargs =\n      model.kwargs != null &&\n      typeof model.kwargs === \"object\" &&\n      \"tools\" in model.kwargs &&\n      Array.isArray(model.kwargs.tools) &&\n      model.kwargs.tools.length > 0;\n\n    const hasToolsInConfig =\n      model.config != null &&\n      typeof model.config === \"object\" &&\n      \"tools\" in model.config &&\n      Array.isArray(model.config.tools) &&\n      model.config.tools.length > 0;\n\n    if (hasToolsInKwargs || hasToolsInConfig) {\n      throw new MultipleToolsBoundError();\n    }\n  }\n\n  /**\n   * Also check if model has tools property directly (e.g., FakeToolCallingModel)\n   */\n  if (\n    \"tools\" in model &&\n    model.tools !== undefined &&\n    Array.isArray(model.tools) &&\n    model.tools.length > 0\n  ) {\n    throw new MultipleToolsBoundError();\n  }\n}\n\n/**\n * Check if the last message in the messages array has tool calls.\n *\n * @param messages - The messages to check.\n * @returns True if the last message has tool calls, false otherwise.\n */\nexport function hasToolCalls(messages: BaseMessage[]): boolean {\n  const lastMessage = messages.at(-1);\n  return Boolean(\n    AIMessage.isInstance(lastMessage) &&\n      lastMessage.tool_calls &&\n      lastMessage.tool_calls.length > 0\n  );\n}\n"],"mappings":"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"}

package/dist/agents/utils.js

@@ -1,6 +1,7 @@
 import { MultipleToolsBoundError } from "./errors.js";
 import { PROMPT_RUNNABLE_NAME } from "./constants.js";
-import { AIMessage, SystemMessage, isAIMessage, isAIMessageChunk, isBaseMessage, isBaseMessageChunk } from "@langchain/core/messages";
+import { isBaseChatModel, isConfigurableModel } from "./model.js";
+import { AIMessage, AIMessageChunk, SystemMessage } from "@langchain/core/messages";
 import { Runnable, RunnableBinding, RunnableLambda, RunnableSequence } from "@langchain/core/runnables";
 
 //#region src/agents/utils.ts
@@ -21,11 +22,11 @@ const CONTENT_PATTERN = /<content>(.*?)<\/content>/s;
 * @internal
 */
 function _addInlineAgentName(message) {
-	const isAI = isBaseMessage(message) && (isAIMessage(message) || isBaseMessageChunk(message) && isAIMessageChunk(message));
-	if (!isAI || !message.name) return message;
+	if (!AIMessage.isInstance(message) || AIMessageChunk.isInstance(message)) return message;
+	if (!message.name) return message;
 	const { name } = message;
 	if (typeof message.content === "string") return new AIMessage({
-		...Object.keys(message.lc_kwargs ?? {}).length > 0 ? message.lc_kwargs : message,
+		...message.lc_kwargs,
 		content: `<name>${name}</name><content>${message.content}</content>`,
 		name: void 0
 	});
@@ -68,7 +69,7 @@ function _addInlineAgentName(message) {
 * @internal
 */
 function _removeInlineAgentName(message) {
-	if (!isAIMessage(message) || !message.content) return message;
+	if (!AIMessage.isInstance(message) || !message.content) return message;
 	let updatedContent = [];
 	let updatedName;
 	if (Array.isArray(message.content)) updatedContent = message.content.filter((block) => {
@@ -112,12 +113,6 @@ function _removeInlineAgentName(message) {
 function isClientTool(tool) {
 	return Runnable.isRunnable(tool);
 }
-function isBaseChatModel(model) {
-	return "invoke" in model && typeof model.invoke === "function" && "_modelType" in model;
-}
-function isConfigurableModel(model) {
-	return typeof model === "object" && model != null && "_queuedMethodOperations" in model && "_model" in model && typeof model._model === "function";
-}
 function _isChatModelWithBindTools(llm) {
 	if (!isBaseChatModel(llm)) return false;
 	return "bindTools" in llm && typeof llm.bindTools === "function";
@@ -130,7 +125,7 @@ function getPromptRunnable(prompt) {
 		promptRunnable = RunnableLambda.from((state) => {
 			return [systemMessage, ...state.messages ?? []];
 		}).withConfig({ runName: PROMPT_RUNNABLE_NAME });
-	} else if (isBaseMessage(prompt) && prompt._getType() === "system") promptRunnable = RunnableLambda.from((state) => [prompt, ...state.messages]).withConfig({ runName: PROMPT_RUNNABLE_NAME });
+	} else if (SystemMessage.isInstance(prompt)) promptRunnable = RunnableLambda.from((state) => [prompt, ...state.messages]).withConfig({ runName: PROMPT_RUNNABLE_NAME });
 	else if (typeof prompt === "function") promptRunnable = RunnableLambda.from(prompt).withConfig({ runName: PROMPT_RUNNABLE_NAME });
 	else if (Runnable.isRunnable(prompt)) promptRunnable = prompt;
 	else throw new Error(`Got unexpected type for 'prompt': ${typeof prompt}`);
@@ -226,21 +221,9 @@ function validateLLMHasNoBoundTools(llm) {
 */
 function hasToolCalls(messages) {
 	const lastMessage = messages.at(-1);
-	return Boolean(lastMessage instanceof AIMessage && lastMessage.tool_calls && lastMessage.tool_calls.length > 0);
-}
-const CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT = ["ChatOpenAI", "FakeToolCallingModel"];
-/**
-* 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 (!isBaseChatModel(model)) return false;
-	const chatModelClass = model.getName();
-	if (CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.includes(chatModelClass) && (chatModelClass === "ChatOpenAI" && "model" in model && typeof model.model === "string" && model.model.startsWith("gpt-4") || chatModelClass === "FakeToolCallingModel" && "structuredResponse" in model)) return true;
-	return false;
+	return Boolean(AIMessage.isInstance(lastMessage) && lastMessage.tool_calls && lastMessage.tool_calls.length > 0);
 }
 
 //#endregion
-export { _addInlineAgentName, _removeInlineAgentName, bindTools, getPromptRunnable, hasSupportForJsonSchemaOutput, hasToolCalls, isClientTool, validateLLMHasNoBoundTools };
+export { _addInlineAgentName, _removeInlineAgentName, bindTools, getPromptRunnable, hasToolCalls, isClientTool, validateLLMHasNoBoundTools };
 //# sourceMappingURL=utils.js.map