langchain 1.0.0-alpha.7 → 1.0.0-alpha.8

package/dist/agents/types.d.cts

@@ -3,18 +3,40 @@ import { JsonSchemaFormat, ProviderStrategy, ResponseFormat, ToolStrategy, Typed
 import { ToolNode } from "./nodes/ToolNode.cjs";
 import { LanguageModelLike } from "@langchain/core/language_models/base";
 import { InteropZodObject, InteropZodType } from "@langchain/core/utils/types";
-import { LangGraphRunnableConfig, START } from "@langchain/langgraph";
 import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/messages";
+import { LangGraphRunnableConfig, START, StateGraph } from "@langchain/langgraph";
 import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
 import { Runnable, RunnableLike, RunnableToolLike } from "@langchain/core/runnables";
 import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
 
 //#region src/agents/types.d.ts
+declare const META_EXTRAS_DESCRIPTION_PREFIX = "lg:";
 type N = typeof START | "agent" | "tools";
 /**
  * Information about a tool call that has been executed.
  */
-
+interface ExecutedToolCall {
+  /**
+   * The name of the tool that was called.
+   */
+  name: string;
+  /**
+   * The arguments that were passed to the tool.
+   */
+  args: Record<string, unknown>;
+  /**
+   * The ID of the tool call.
+   */
+  tool_id: string;
+  /**
+   * The result of the tool call (if available).
+   */
+  result?: unknown;
+}
+/**
+ * Type helper to extract the inferred type from a single Zod schema or array of schemas
+ */
+type ExtractZodType<T> = T extends InteropZodType<infer U> ? U : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : never;
 /**
  * Type helper to extract union type from an array of Zod schemas
  */
@@ -22,7 +44,13 @@ type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends
 /**
  * Type helper to extract the structured response type from responseFormat
  */
-
+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
+: T extends ResponseFormat ? Record<string, any> // Single ResponseFormat will be handled at runtime
+: Record<string, any>;
+/** @internal */
+type ReducedZodChannel<T extends InteropZodType, TReducerSchema extends InteropZodType> = T & {
+  lg_reducer_schema: TReducerSchema;
+};
 type ServerTool = Record<string, unknown>;
 type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;
 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;
@@ -267,10 +295,16 @@ type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject
    */
   version?: "v1" | "v2";
 };
+type InternalAgentState<StructuredResponseType extends Record<string, unknown> | undefined = Record<string, unknown>> = {
+  messages: BaseMessage[];
+} & (StructuredResponseType extends ResponseFormatUndefined ? Record<string, never> : {
+  structuredResponse: StructuredResponseType;
+});
+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;
 /**
  * @deprecated likely to be removed in the next version of the agent
  */
 type 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;
 //#endregion
-export { AgentRuntime, AgentState, ClientTool, CreateAgentParams, ExtractZodArrayTypes, N, Prompt, ServerTool };
+export { AgentRuntime, AgentState, ClientTool, CreateAgentParams, ExecutedToolCall, ExtractZodArrayTypes, ExtractZodType, InferResponseFormatType, InternalAgentState, META_EXTRAS_DESCRIPTION_PREFIX, N, Prompt, ReducedZodChannel, ServerTool, WithStateGraphNodes };
 //# sourceMappingURL=types.d.cts.map

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

@@ -1 +1 @@
-{"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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"}
+{"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","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 * 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

@@ -6,15 +6,37 @@ import { Runnable, RunnableLike, RunnableToolLike } from "@langchain/core/runnab
 import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
 import { LangGraphRunnableConfig, START, StateGraph } from "@langchain/langgraph";
 import { InteropZodObject, InteropZodType } from "@langchain/core/utils/types";
-import { LanguageModelLike } from "@langchain/core/language_models/base";
 import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
 
 //#region src/agents/types.d.ts
+declare const META_EXTRAS_DESCRIPTION_PREFIX = "lg:";
 type N = typeof START | "agent" | "tools";
 /**
  * Information about a tool call that has been executed.
  */
-
+interface ExecutedToolCall {
+  /**
+   * The name of the tool that was called.
+   */
+  name: string;
+  /**
+   * The arguments that were passed to the tool.
+   */
+  args: Record<string, unknown>;
+  /**
+   * The ID of the tool call.
+   */
+  tool_id: string;
+  /**
+   * The result of the tool call (if available).
+   */
+  result?: unknown;
+}
+/**
+ * Type helper to extract the inferred type from a single Zod schema or array of schemas
+ */
+type ExtractZodType<T> = T extends InteropZodType<infer U> ? U : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : never;
 /**
  * Type helper to extract union type from an array of Zod schemas
  */
@@ -22,7 +44,13 @@ type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends
 /**
  * Type helper to extract the structured response type from responseFormat
  */
-
+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
+: T extends ResponseFormat ? Record<string, any> // Single ResponseFormat will be handled at runtime
+: Record<string, any>;
+/** @internal */
+type ReducedZodChannel<T extends InteropZodType, TReducerSchema extends InteropZodType> = T & {
+  lg_reducer_schema: TReducerSchema;
+};
 type ServerTool = Record<string, unknown>;
 type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;
 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;
@@ -267,10 +295,16 @@ type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject
    */
   version?: "v1" | "v2";
 };
+type InternalAgentState<StructuredResponseType extends Record<string, unknown> | undefined = Record<string, unknown>> = {
+  messages: BaseMessage[];
+} & (StructuredResponseType extends ResponseFormatUndefined ? Record<string, never> : {
+  structuredResponse: StructuredResponseType;
+});
+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;
 /**
  * @deprecated likely to be removed in the next version of the agent
  */
 type 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;
 //#endregion
-export { AgentRuntime, AgentState, ClientTool, CreateAgentParams, ExtractZodArrayTypes, N, Prompt, ServerTool };
+export { AgentRuntime, AgentState, ClientTool, CreateAgentParams, ExecutedToolCall, ExtractZodArrayTypes, ExtractZodType, InferResponseFormatType, InternalAgentState, META_EXTRAS_DESCRIPTION_PREFIX, N, Prompt, ReducedZodChannel, ServerTool, WithStateGraphNodes };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"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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"}
+{"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","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 * 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.js

@@ -0,0 +1,6 @@
+//#region src/agents/types.ts
+const META_EXTRAS_DESCRIPTION_PREFIX = "lg:";
+
+//#endregion
+export { META_EXTRAS_DESCRIPTION_PREFIX };
+//# sourceMappingURL=types.js.map

package/dist/agents/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/agents/types.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type {\n  InteropZodObject,\n  InteropZodType,\n} from \"@langchain/core/utils/types\";\nimport type {\n  LangGraphRunnableConfig,\n  START,\n  StateGraph,\n} from \"@langchain/langgraph\";\n\nimport type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type {\n  SystemMessage,\n  BaseMessageLike,\n  BaseMessage,\n} from \"@langchain/core/messages\";\nimport type {\n  All,\n  BaseCheckpointSaver,\n  BaseStore,\n} from \"@langchain/langgraph-checkpoint\";\nimport type {\n  DynamicTool,\n  StructuredToolInterface,\n} from \"@langchain/core/tools\";\nimport type {\n  Runnable,\n  RunnableLike,\n  RunnableToolLike,\n} from \"@langchain/core/runnables\";\nimport type { ToolNode } from \"./nodes/ToolNode.js\";\nimport type {\n  PreHookAnnotation,\n  AnyAnnotationRoot,\n  ToAnnotationRoot,\n  ResponseFormatUndefined,\n} from \"./annotation.js\";\nimport type {\n  ResponseFormat,\n  ToolStrategy,\n  TypedToolStrategy,\n  ProviderStrategy,\n  JsonSchemaFormat,\n} from \"./responses.js\";\n\nexport const META_EXTRAS_DESCRIPTION_PREFIX = \"lg:\";\n\nexport type N = typeof START | \"agent\" | \"tools\";\n\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/**\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>\n  ? U\n  : T extends readonly InteropZodType<any>[]\n  ? ExtractZodArrayTypes<T>\n  : never;\n\n/**\n * Type helper to extract union type from an array of Zod schemas\n */\nexport type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> =\n  T extends readonly [InteropZodType<infer A>, ...infer Rest]\n    ? Rest extends readonly InteropZodType<any>[]\n      ? A | ExtractZodArrayTypes<Rest>\n      : A\n    : never;\n\n/**\n * Type helper to extract the structured response type from responseFormat\n */\nexport type InferResponseFormatType<T> = T extends InteropZodType<infer U>\n  ? U extends Record<string, any>\n    ? U\n    : Record<string, any>\n  : T extends readonly InteropZodType<any>[]\n  ? ExtractZodArrayTypes<T>\n  : T extends ToolStrategy[]\n  ? Record<string, any> // ToolStrategy arrays will be handled at runtime\n  : T extends ResponseFormat\n  ? Record<string, any> // Single ResponseFormat will be handled at runtime\n  : Record<string, any>;\n\n/** @internal */\nexport type ReducedZodChannel<\n  T extends InteropZodType,\n  TReducerSchema extends InteropZodType\n> = T & {\n  lg_reducer_schema: TReducerSchema;\n};\n\nexport type ServerTool = Record<string, unknown>;\nexport type ClientTool =\n  | StructuredToolInterface\n  | DynamicTool\n  | RunnableToolLike;\n\nexport type Prompt<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n> =\n  | SystemMessage\n  | string\n  | ((\n      state: ToAnnotationRoot<StateSchema>[\"State\"] &\n        PreHookAnnotation[\"State\"],\n      config: LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>\n    ) => BaseMessageLike[] | Promise<BaseMessageLike[]>)\n  | Runnable;\n\nexport type AgentState<\n  AnnotationRoot extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot\n> = ToAnnotationRoot<AnnotationRoot>[\"State\"] & PreHookAnnotation[\"State\"];\n\nexport interface AgentRuntime<ContextType = Record<string, unknown>> {\n  /**\n   * The context of the agent.\n   */\n  context?: ContextType;\n\n  /**\n   * The store passed to the agent.\n   */\n  store?: BaseStore;\n\n  /**\n   * The writer of the agent to write to the output stream.\n   */\n  writer?: (chunk: unknown) => void;\n\n  /**\n   * An optional abort signal that indicates that the overall operation should be aborted.\n   */\n  signal?: AbortSignal;\n}\n\nexport type CreateAgentParams<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,\n  StructuredResponseType extends Record<string, unknown> = Record<\n    string,\n    unknown\n  >,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  ResponseFormatType =\n    | InteropZodType<StructuredResponseType>\n    | InteropZodType<unknown>[]\n    | JsonSchemaFormat\n    | JsonSchemaFormat[]\n    | ResponseFormat\n    | TypedToolStrategy<StructuredResponseType>\n    | ToolStrategy<StructuredResponseType>\n    | ProviderStrategy<StructuredResponseType>\n    | ResponseFormatUndefined\n> = {\n  /** The chat model that can utilize OpenAI-style tool calling. */\n  llm?: LanguageModelLike | DynamicLLMFunction<StateSchema, ContextSchema>;\n\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\n  /** A list of tools or a ToolNode. */\n  tools: ToolNode | (ServerTool | ClientTool)[];\n\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  /**\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  /**\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  /**\n   * An optional name for the agent.\n   */\n  name?: string;\n\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  /**\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  /**\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<\n    ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"],\n    ToAnnotationRoot<StateSchema>[\"Update\"] & PreHookAnnotation[\"Update\"],\n    LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>\n  >;\n\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<\n    ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"],\n    ToAnnotationRoot<StateSchema>[\"Update\"] & PreHookAnnotation[\"Update\"],\n    LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>\n  >;\n\n  /**\n   * An optional abort signal that indicates that the overall operation should be aborted.\n   */\n  signal?: AbortSignal;\n\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};\n\nexport type InternalAgentState<\n  StructuredResponseType extends Record<string, unknown> | undefined = Record<\n    string,\n    unknown\n  >\n> = {\n  messages: BaseMessage[];\n  // TODO: This won't be set until we\n  // implement managed values in LangGraphJS\n  // Will be useful for inserting a message on\n  // graph recursion end\n  // is_last_step: boolean;\n} & (StructuredResponseType extends ResponseFormatUndefined\n  ? Record<string, never>\n  : { structuredResponse: StructuredResponseType });\n\nexport type WithStateGraphNodes<\n  K extends string,\n  Graph\n> = Graph extends StateGraph<\n  infer SD,\n  infer S,\n  infer U,\n  infer N,\n  infer I,\n  infer O,\n  infer C\n>\n  ? StateGraph<SD, S, U, N | K, I, O, C>\n  : never;\n\n/**\n * @deprecated likely to be removed in the next version of the agent\n */\ntype DynamicLLMFunction<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n> = (\n  state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"],\n  runtime: AgentRuntime<ToAnnotationRoot<ContextSchema>[\"State\"]>\n) => Promise<LanguageModelLike> | LanguageModelLike;\n"],"mappings":";AA8CA,MAAa,iCAAiC"}

package/dist/chat_models/universal.cjs

@@ -78,6 +78,11 @@ const MODEL_PROVIDER_CONFIG = {
 		package: "@langchain/community/chat_models/togetherai",
 		className: "ChatTogetherAI",
 		hasCircularDependency: true
+	},
+	perplexity: {
+		package: "@langchain/community/chat_models/perplexity",
+		className: "ChatPerplexity",
+		hasCircularDependency: true
 	}
 };
 const SUPPORTED_PROVIDERS = Object.keys(MODEL_PROVIDER_CONFIG);
@@ -136,6 +141,7 @@ function _inferModelProvider(modelName) {
 	else if (modelName.startsWith("gemini")) return "google-vertexai";
 	else if (modelName.startsWith("amazon.")) return "bedrock";
 	else if (modelName.startsWith("mistral")) return "mistralai";
+	else if (modelName.startsWith("sonar") || modelName.startsWith("pplx")) return "perplexity";
 	else return void 0;
 }
 /**
@@ -315,6 +321,7 @@ var ConfigurableModel = class ConfigurableModel extends __langchain_core_languag
 *   - mistralai (@langchain/mistralai)
 *   - groq (@langchain/groq)
 *   - ollama (@langchain/ollama)
+*   - perplexity (@langchain/community/chat_models/perplexity)
 *   - cerebras (@langchain/cerebras)
 *   - deepseek (@langchain/deepseek)
 *   - xai (@langchain/xai)