langchain 1.0.0-alpha.8 → 1.0.1

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","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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"}
+{"version":3,"file":"types.d.cts","names":["InteropZodObject","InteropZodType","START","END","StateGraph","LanguageModelLike","BaseMessage","BaseCheckpointSaver","BaseStore","Messages","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","JsonSchemaFormat","ResponseFormatUndefined","AgentMiddleware","AnyAnnotationRoot","InferSchemaInput","ServerTool","ClientTool","JumpToTarget","N","Interrupt","TValue","BuiltInState","UserInput","TStateSchema","ToolCall","Record","ToolResult","JumpTo","ExecutedToolCall","CreateAgentParams","StructuredResponseType","StateSchema","ContextSchema","ResponseFormatType","AbortSignal","ExtractZodArrayTypes","T","Rest","A","WithStateGraphNodes","Graph","SD","S","U","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 { START, END, StateGraph } from \"@langchain/langgraph\";\nimport type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport type { Messages } from \"@langchain/langgraph/\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, JsonSchemaFormat, ResponseFormatUndefined } from \"./responses.js\";\nimport type { AgentMiddleware, AnyAnnotationRoot, InferSchemaInput } from \"./middleware/types.js\";\nimport type { ServerTool, ClientTool } from \"./tools.js\";\nimport type { JumpToTarget } from \"./constants.js\";\nexport type N = typeof START | \"model_request\" | \"tools\";\n/**\n * Represents information about an interrupt.\n */\nexport interface Interrupt<TValue = unknown> {\n    /**\n     * The ID of the interrupt.\n     */\n    id: string;\n    /**\n     * The requests for human input.\n     */\n    value: TValue;\n}\nexport interface BuiltInState {\n    messages: BaseMessage[];\n    __interrupt__?: Interrupt[];\n    /**\n     * Optional property to control routing after afterModel middleware execution.\n     * When set by middleware, the agent will jump to the specified node instead of\n     * following normal routing logic. The property is automatically cleared after use.\n     *\n     * - \"model_request\": Jump back to the model for another LLM call\n     * - \"tools\": Jump to tool execution (requires tools to be available)\n     */\n    jumpTo?: JumpToTarget;\n}\n/**\n * Base input type for `.invoke` and `.stream` methods.\n */\nexport type UserInput<TStateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined> = InferSchemaInput<TStateSchema> & {\n    messages: Messages;\n};\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ToolCall {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\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, any>;\n    /**\n     * The result of the tool call.\n     */\n    result?: unknown;\n    /**\n     * An optional error message if the tool call failed.\n     */\n    error?: string;\n}\n/**\n * Information about a tool result from a tool execution.\n */\nexport interface ToolResult {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The result of the tool call.\n     */\n    result: any;\n    /**\n     * An optional error message if the tool call failed.\n     */\n    error?: string;\n}\n/**\n * jump targets (internal)\n */\nexport type JumpTo = \"model_request\" | \"tools\" | typeof END;\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}\nexport type CreateAgentParams<StructuredResponseType extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\n    /**\n     * Defines a model to use for the agent. You can either pass in an instance of a LangChain chat model\n     * or a string. If a string is provided the agent 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     * @example\n     * ```ts\n     * import { ChatOpenAI } from \"@langchain/openai\";\n     * const agent = createAgent({\n     *   model: new ChatOpenAI({ model: \"gpt-4o\" }),\n     *   // ...\n     * });\n     * ```\n     */\n    model: string | LanguageModelLike;\n    /**\n     * A list of tools or a ToolNode.\n     *\n     * @example\n     * ```ts\n     * import { tool } from \"langchain\";\n     *\n     * const weatherTool = tool(() => \"Sunny!\", {\n     *   name: \"get_weather\",\n     *   description: \"Get the weather for a location\",\n     *   schema: z.object({\n     *     location: z.string().describe(\"The location to get weather for\"),\n     *   }),\n     * });\n     *\n     * const agent = createAgent({\n     *   tools: [weatherTool],\n     *   // ...\n     * });\n     * ```\n     */\n    tools?: (ServerTool | ClientTool)[];\n    /**\n     * An optional system message for the model.\n     */\n    systemPrompt?: string;\n    /**\n     * An optional schema for the agent state. It allows you to define custom state properties that persist\n     * across agent invocations and can be accessed in hooks, middleware, and throughout the agent's execution.\n     * The state is persisted when using a checkpointer and can be updated by middleware or during execution.\n     *\n     * As opposed to the context (defined in `contextSchema`), the state is persisted between agent invocations\n     * when using a checkpointer, making it suitable for maintaining conversation history, user preferences,\n     * or any other data that should persist across multiple interactions.\n     *\n     * @example\n     * ```ts\n     * import { z } from \"zod\";\n     * import { createAgent } from \"@langchain/langgraph\";\n     *\n     * const agent = createAgent({\n     *   model: \"openai:gpt-4o\",\n     *   tools: [getWeather],\n     *   stateSchema: z.object({\n     *     userPreferences: z.object({\n     *       temperatureUnit: z.enum([\"celsius\", \"fahrenheit\"]).default(\"celsius\"),\n     *       location: z.string().optional(),\n     *     }).optional(),\n     *     conversationCount: z.number().default(0),\n     *   }),\n     *   prompt: (state, config) => {\n     *     const unit = state.userPreferences?.temperatureUnit || \"celsius\";\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. Use ${unit} for temperature.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new HumanMessage(\"What's the weather like?\"),\n     *   ],\n     *   userPreferences: {\n     *     temperatureUnit: \"fahrenheit\",\n     *     location: \"New York\",\n     *   },\n     *   conversationCount: 1,\n     * });\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` and middleware.\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    /**\n     * An optional checkpoint saver to persist the agent's state.\n     * @see {@link https://docs.langchain.com/oss/javascript/langgraph/persistence | Checkpointing}\n     */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /**\n     * An optional store to persist the agent's state.\n     * @see {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Long-term memory}\n     */\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     * Middleware instances to run during agent execution.\n     * Each middleware can define its own state schema and hook into the agent lifecycle.\n     *\n     * @see {@link https://docs.langchain.com/oss/javascript/langchain/middleware | Middleware}\n     */\n    middleware?: readonly AgentMiddleware<any, any, any>[];\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 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};\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;\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"],"mappings":";;;;;;;;;;;;KAWYsB,CAAAA,UAAWpB;AAAvB;AAIA;AAUA;AAA6B,UAVZqB,SAUY,CAAA,SAAA,OAAA,CAAA,CAAA;EAAA;;;EAWJ,EAAA,EAAA,MAAA;EAKbG;;;EAAgD,KAAG1B,EAlBpDwB,MAkBoDxB;;AAA4CkB,UAhB1FO,YAAAA,CAgB0FP;EAAgB,QAC7GT,EAhBAH,WAgBAG,EAAAA;EAAQ,aAAA,CAAA,EAfFc,SAeE,EAAA;EAKLK;AAyBjB;AAiBA;AAIA;AAkBA;;;;EAAyF,MAAmCX,CAAAA,EA3E/GI,YA2E+GJ;;;;;AAAkLiB,KAtElSR,SAsEkSQ,CAAAA,qBAtEnQjB,iBAsEmQiB,GAtE/OlC,gBAsE+OkC,GAAAA,SAAAA,GAAAA,SAAAA,CAAAA,GAtEnMhB,gBAsEmMgB,CAtElLP,YAsEkLO,CAAAA,GAAAA;EAAsB,QAArCjC,EArEjRQ,QAqEiRR;CAAc;;;;AAAkIiC,UAhE9ZN,UAAAA,CAgE8ZM;EAAsB;;;EAAgB,EAAA,EAA4CA,MAAAA;EAAsB;;;EAwBlf,IAsBxBf,EAAAA,MAAAA;EAAU;;;EAmFU,IAKdZ,EA1LTsB,MA0LStB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAAmB;;;EAkEG,MAoB5B+B,CAAAA,EAAAA,OAAAA;EAAW;AAiBxB;;EAAgC,KAAoBrC,CAAAA,EAAAA,MAAAA;;;;;AAAqIyC,UApRxKZ,UAAAA,CAoRwKY;EAAC;;;EAAiC,EAAA,EAAA,MAAA;EAC/MC;;;EAAoD,MAASvC,EAAAA,GAAAA;EAAU;;;EAAsF,KAAEkB,CAAAA,EAAAA,MAAAA;;;;;AAArBlB,KApQ1I2B,MAAAA,GAoQ0I3B,eAAAA,GAAAA,OAAAA,GAAAA,OApQ9FD,GAoQ8FC;AAAU;;;UAhQ/I4B,gBAAAA;;;;;;;;QAQPH;;;;;;;;;;KAUEI,iDAAiDJ,sBAAsBA,yCAAyCZ,oBAAoBjB,gEAAgEiB,oBAAoBjB,mBAAmBiB,wCAAwChB,eAAeiC,0BAA0BjC,4BAA4Ba,mBAAmBA,qBAAqBJ,iBAAiBE,kBAAkBsB,0BAA0BvB,aAAauB,0BAA0BrB,iBAAiBqB,0BAA0BnB;;;;;;;;;;;;;;;;;;;;;;;;kBAwBvgBV;;;;;;;;;;;;;;;;;;;;;;WAsBPc,aAAaC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAiDRe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkCEC;;;;;iBAKD7B;;;;;UAKPC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsDS6B;;;;;;;wBAOKrB;;;;;;;;;;;;;;;;;;;;WAoBbsB;;;;;;;;;;;;;;;;;KAiBDC,wCAAwCtC,yBAAyBuC,oBAAoBvC,0CAA0CwC,sBAAsBxC,wBAAwByC,IAAIH,qBAAqBE,QAAQC;KAC9MC,+CAA+CC,cAAcxC,6EAA6EA,WAAWyC,IAAIC,GAAGC,GAAGzB,IAAI0B,GAAGC,GAAGC,GAAGC"}

package/dist/agents/types.d.ts

@@ -1,21 +1,56 @@
-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 { Runnable, RunnableLike, RunnableToolLike } from "@langchain/core/runnables";
-import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
-import { LangGraphRunnableConfig, START, StateGraph } from "@langchain/langgraph";
+import { JsonSchemaFormat, ProviderStrategy, ResponseFormat, ResponseFormatUndefined, ToolStrategy, TypedToolStrategy } from "./responses.js";
+import { JumpToTarget } from "./constants.js";
+import { ClientTool, ServerTool } from "./tools.js";
+import { AgentMiddleware, AnyAnnotationRoot, InferSchemaInput } from "./middleware/types.js";
+import { BaseMessage } from "@langchain/core/messages";
+import { END, START, StateGraph } from "@langchain/langgraph";
 import { InteropZodObject, InteropZodType } from "@langchain/core/utils/types";
-import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
+import { BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
 import { LanguageModelLike } from "@langchain/core/language_models/base";
+import { Messages } from "@langchain/langgraph/";
 
 //#region src/agents/types.d.ts
-declare const META_EXTRAS_DESCRIPTION_PREFIX = "lg:";
-type N = typeof START | "agent" | "tools";
+type N = typeof START | "model_request" | "tools";
+/**
+ * Represents information about an interrupt.
+ */
+interface Interrupt<TValue = unknown> {
+  /**
+   * The ID of the interrupt.
+   */
+  id: string;
+  /**
+   * The requests for human input.
+   */
+  value: TValue;
+}
+interface BuiltInState {
+  messages: BaseMessage[];
+  __interrupt__?: Interrupt[];
+  /**
+   * Optional property to control routing after afterModel middleware execution.
+   * When set by middleware, the agent will jump to the specified node instead of
+   * following normal routing logic. The property is automatically cleared after use.
+   *
+   * - "model_request": Jump back to the model for another LLM call
+   * - "tools": Jump to tool execution (requires tools to be available)
+   */
+  jumpTo?: JumpToTarget;
+}
+/**
+ * Base input type for `.invoke` and `.stream` methods.
+ */
+type UserInput<TStateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined> = InferSchemaInput<TStateSchema> & {
+  messages: Messages;
+};
 /**
  * Information about a tool call that has been executed.
  */
-interface ExecutedToolCall {
+interface ToolCall$1 {
+  /**
+   * The ID of the tool call.
+   */
+  id: string;
   /**
    * The name of the tool that was called.
    */
@@ -23,61 +58,62 @@ interface ExecutedToolCall {
   /**
    * The arguments that were passed to the tool.
    */
-  args: Record<string, unknown>;
+  args: Record<string, any>;
   /**
-   * The ID of the tool call.
+   * The result of the tool call.
    */
-  tool_id: string;
+  result?: unknown;
   /**
-   * The result of the tool call (if available).
+   * An optional error message if the tool call failed.
    */
-  result?: unknown;
+  error?: string;
 }
 /**
- * Type helper to extract the inferred type from a single Zod schema or array of schemas
+ * Information about a tool result from a tool execution.
  */
-type ExtractZodType<T> = T extends InteropZodType<infer U> ? U : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : never;
+interface ToolResult {
+  /**
+   * The ID of the tool call.
+   */
+  id: string;
+  /**
+   * The result of the tool call.
+   */
+  result: any;
+  /**
+   * An optional error message if the tool call failed.
+   */
+  error?: string;
+}
 /**
- * Type helper to extract union type from an array of Zod schemas
+ * jump targets (internal)
  */
-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;
+type JumpTo = "model_request" | "tools" | typeof END;
 /**
- * Type helper to extract the structured response type from responseFormat
+ * Information about a tool call that has been executed.
  */
-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;
-type AgentState<AnnotationRoot extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = ToAnnotationRoot<AnnotationRoot>["State"] & PreHookAnnotation["State"];
-interface AgentRuntime<ContextType = Record<string, unknown>> {
+interface ExecutedToolCall {
   /**
-   * The context of the agent.
+   * The name of the tool that was called.
    */
-  context?: ContextType;
+  name: string;
   /**
-   * The store passed to the agent.
+   * The arguments that were passed to the tool.
    */
-  store?: BaseStore;
+  args: Record<string, unknown>;
   /**
-   * The writer of the agent to write to the output stream.
+   * The ID of the tool call.
    */
-  writer?: (chunk: unknown) => void;
+  tool_id: string;
   /**
-   * An optional abort signal that indicates that the overall operation should be aborted.
+   * The result of the tool call (if available).
    */
-  signal?: AbortSignal;
+  result?: unknown;
 }
-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>;
+type CreateAgentParams<StructuredResponseType extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {
   /**
-   * Initializes a ChatModel based on the provided model name and provider.
+   * Defines a model to use for the agent. You can either pass in an instance of a LangChain chat model
+   * or a string. If a string is provided the agent initializes a ChatModel based on the provided model name and provider.
    * It supports various model providers and allows for runtime configuration of model parameters.
    *
    * @uses {@link initChatModel}
@@ -88,76 +124,91 @@ type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject
    *   // ...
    * });
    * ```
+   *
+   * @example
+   * ```ts
+   * import { ChatOpenAI } from "@langchain/openai";
+   * const agent = createAgent({
+   *   model: new ChatOpenAI({ model: "gpt-4o" }),
+   *   // ...
+   * });
+   * ```
    */
-  model?: string;
-  /** A list of tools or a ToolNode. */
-  tools: ToolNode | (ServerTool | ClientTool)[];
+  model: string | LanguageModelLike;
   /**
-   * An optional prompt for the LLM. This takes full graph state BEFORE the LLM is called and prepares the input to LLM.
-   *
-   * Can take a few different forms:
+   * A list of tools or a ToolNode.
    *
-   * - str: This is converted to a SystemMessage and added to the beginning of the list of messages in state["messages"].
-   * - SystemMessage: this is added to the beginning of the list of messages in state["messages"].
-   * - Function: This function should take in full graph state and the output is then passed to the language model.
-   * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.
+   * @example
+   * ```ts
+   * import { tool } from "langchain";
    *
-   * Note:
-   * Prior to `v0.2.46`, the prompt was set using `stateModifier` / `messagesModifier` parameters.
-   * This is now deprecated and will be removed in a future release.
+   * const weatherTool = tool(() => "Sunny!", {
+   *   name: "get_weather",
+   *   description: "Get the weather for a location",
+   *   schema: z.object({
+   *     location: z.string().describe("The location to get weather for"),
+   *   }),
+   * });
    *
-   * Cannot be used together with `prepareCall`.
+   * const agent = createAgent({
+   *   tools: [weatherTool],
+   *   // ...
+   * });
+   * ```
+   */
+  tools?: (ServerTool | ClientTool)[];
+  /**
+   * An optional system message for the model.
    */
-  prompt?: Prompt<StateSchema, ContextSchema>;
+  systemPrompt?: string;
   /**
-   * Additional state schema for the agent. It allows to define additional state keys that will be
-   * persisted between agent invocations.
+   * An optional schema for the agent state. It allows you to define custom state properties that persist
+   * across agent invocations and can be accessed in hooks, middleware, and throughout the agent's execution.
+   * The state is persisted when using a checkpointer and can be updated by middleware or during execution.
+   *
+   * As opposed to the context (defined in `contextSchema`), the state is persisted between agent invocations
+   * when using a checkpointer, making it suitable for maintaining conversation history, user preferences,
+   * or any other data that should persist across multiple interactions.
    *
    * @example
    * ```ts
-   * // State schema defines data that persists across agent invocations
-   * const stateSchema = z.object({
-   *   userPreferences: z.object({
-   *     theme: z.enum(["light", "dark"]),
-   *     language: z.string(),
-   *   }),
-   *   taskHistory: z.array(z.string()),
-   *   currentWorkflow: z.string().optional(),
-   * });
-   *
-   * // Context schema defines runtime parameters passed per invocation
-   * const contextSchema = z.object({ ... });
+   * import { z } from "zod";
+   * import { createAgent } from "@langchain/langgraph";
    *
    * const agent = createAgent({
-   *   llm: model,
-   *   tools: [updatePreferences, addTask],
-   *   stateSchema,    // Persisted: preferences, e.g. task history, workflow state
-   *   contextSchema,  // Per-invocation: user ID, session, API keys, etc.
+   *   model: "openai:gpt-4o",
+   *   tools: [getWeather],
+   *   stateSchema: z.object({
+   *     userPreferences: z.object({
+   *       temperatureUnit: z.enum(["celsius", "fahrenheit"]).default("celsius"),
+   *       location: z.string().optional(),
+   *     }).optional(),
+   *     conversationCount: z.number().default(0),
+   *   }),
    *   prompt: (state, config) => {
-   *     // ...
+   *     const unit = state.userPreferences?.temperatureUnit || "celsius";
+   *     return [
+   *       new SystemMessage(`You are a helpful assistant. Use ${unit} for temperature.`),
+   *     ];
    *   },
    * });
    *
-   * // First invocation - state starts empty, context provided
-   * await agent.invoke({
-   *   messages: [new HumanMessage("Set my theme to dark")],
-   * }, {
-   *   context: { userId: "user123", sessionId: "sess456", apiKeys: {...} }
-   * });
-   *
-   * // Second invocation - state persists, new context
-   * await agent.invoke({
-   *   messages: [new HumanMessage("Add a task to review code")],
-   * }, {
-   *   context: { userId: "user123", sessionId: "sess789", apiKeys: {...} }
+   * const result = await agent.invoke({
+   *   messages: [
+   *     new HumanMessage("What's the weather like?"),
+   *   ],
+   *   userPreferences: {
+   *     temperatureUnit: "fahrenheit",
+   *     location: "New York",
+   *   },
+   *   conversationCount: 1,
    * });
-   * // State now contains: userPreferences.theme="dark", taskHistory=["review code"]
    * ```
    */
   stateSchema?: StateSchema;
   /**
    * An optional schema for the context. It allows to pass in a typed context object into the agent
-   * invocation and allows to access it in hooks such as `prompt`, `preModelHook`, `postModelHook`, etc.
+   * invocation and allows to access it in hooks such as `prompt` and middleware.
    * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between
    * agent invocations.
    *
@@ -189,14 +240,15 @@ type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject
    * ```
    */
   contextSchema?: ContextSchema;
-  /** An optional checkpoint saver to persist the agent's state. */
-  checkpointSaver?: BaseCheckpointSaver | boolean;
-  /** An optional checkpoint saver to persist the agent's state. Alias of "checkpointSaver". */
+  /**
+   * An optional checkpoint saver to persist the agent's state.
+   * @see {@link https://docs.langchain.com/oss/javascript/langgraph/persistence | Checkpointing}
+   */
   checkpointer?: BaseCheckpointSaver | boolean;
-  /** An optional list of node names to interrupt before running. */
-  interruptBefore?: N[] | All;
-  /** An optional list of node names to interrupt after running. */
-  interruptAfter?: N[] | All;
+  /**
+   * An optional store to persist the agent's state.
+   * @see {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Long-term memory}
+   */
   store?: BaseStore;
   /**
    * An optional schema for the final agent output.
@@ -252,6 +304,13 @@ type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject
    * 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/).
    */
   responseFormat?: ResponseFormatType;
+  /**
+   * Middleware instances to run during agent execution.
+   * Each middleware can define its own state schema and hook into the agent lifecycle.
+   *
+   * @see {@link https://docs.langchain.com/oss/javascript/langchain/middleware | Middleware}
+   */
+  middleware?: readonly AgentMiddleware<any, any, any>[];
   /**
    * An optional name for the agent.
    */
@@ -268,16 +327,6 @@ type CreateAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject
    *       Example: `"How can I help you"` -> `"<name>agent_name</name><content>How can I help you?</content>"`
    */
   includeAgentName?: "inline" | undefined;
-  /**
-   * An optional node to add before the `agent` node (i.e., the node that calls the LLM).
-   * Useful for managing long message histories (e.g., message trimming, summarization, etc.).
-   */
-  preModelHook?: RunnableLike<ToAnnotationRoot<StateSchema>["State"] & PreHookAnnotation["State"], ToAnnotationRoot<StateSchema>["Update"] & PreHookAnnotation["Update"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>["State"]>>;
-  /**
-   * An optional node to add after the `agent` node (i.e., the node that calls the LLM).
-   * Useful for implementing human-in-the-loop, guardrails, validation, or other post-processing.
-   */
-  postModelHook?: RunnableLike<ToAnnotationRoot<StateSchema>["State"] & PreHookAnnotation["State"], ToAnnotationRoot<StateSchema>["Update"] & PreHookAnnotation["Update"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>["State"]>>;
   /**
    * An optional abort signal that indicates that the overall operation should be aborted.
    */
@@ -295,16 +344,11 @@ 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 helper to extract union type from an array of Zod schemas
  */
-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;
+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;
+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;
 //#endregion
-export { AgentRuntime, AgentState, ClientTool, CreateAgentParams, ExecutedToolCall, ExtractZodArrayTypes, ExtractZodType, InferResponseFormatType, InternalAgentState, META_EXTRAS_DESCRIPTION_PREFIX, N, Prompt, ReducedZodChannel, ServerTool, WithStateGraphNodes };
+export { BuiltInState, CreateAgentParams, ExecutedToolCall, ExtractZodArrayTypes, Interrupt, JumpTo, N, ToolCall$1 as ToolCall, ToolResult, UserInput, 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","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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"}
+{"version":3,"file":"types.d.ts","names":["InteropZodObject","InteropZodType","START","END","StateGraph","LanguageModelLike","BaseMessage","BaseCheckpointSaver","BaseStore","Messages","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","JsonSchemaFormat","ResponseFormatUndefined","AgentMiddleware","AnyAnnotationRoot","InferSchemaInput","ServerTool","ClientTool","JumpToTarget","N","Interrupt","TValue","BuiltInState","UserInput","TStateSchema","ToolCall","Record","ToolResult","JumpTo","ExecutedToolCall","CreateAgentParams","StructuredResponseType","StateSchema","ContextSchema","ResponseFormatType","AbortSignal","ExtractZodArrayTypes","T","Rest","A","WithStateGraphNodes","Graph","SD","S","U","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 { START, END, StateGraph } from \"@langchain/langgraph\";\nimport type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport type { Messages } from \"@langchain/langgraph/\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, JsonSchemaFormat, ResponseFormatUndefined } from \"./responses.js\";\nimport type { AgentMiddleware, AnyAnnotationRoot, InferSchemaInput } from \"./middleware/types.js\";\nimport type { ServerTool, ClientTool } from \"./tools.js\";\nimport type { JumpToTarget } from \"./constants.js\";\nexport type N = typeof START | \"model_request\" | \"tools\";\n/**\n * Represents information about an interrupt.\n */\nexport interface Interrupt<TValue = unknown> {\n    /**\n     * The ID of the interrupt.\n     */\n    id: string;\n    /**\n     * The requests for human input.\n     */\n    value: TValue;\n}\nexport interface BuiltInState {\n    messages: BaseMessage[];\n    __interrupt__?: Interrupt[];\n    /**\n     * Optional property to control routing after afterModel middleware execution.\n     * When set by middleware, the agent will jump to the specified node instead of\n     * following normal routing logic. The property is automatically cleared after use.\n     *\n     * - \"model_request\": Jump back to the model for another LLM call\n     * - \"tools\": Jump to tool execution (requires tools to be available)\n     */\n    jumpTo?: JumpToTarget;\n}\n/**\n * Base input type for `.invoke` and `.stream` methods.\n */\nexport type UserInput<TStateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined> = InferSchemaInput<TStateSchema> & {\n    messages: Messages;\n};\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ToolCall {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\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, any>;\n    /**\n     * The result of the tool call.\n     */\n    result?: unknown;\n    /**\n     * An optional error message if the tool call failed.\n     */\n    error?: string;\n}\n/**\n * Information about a tool result from a tool execution.\n */\nexport interface ToolResult {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The result of the tool call.\n     */\n    result: any;\n    /**\n     * An optional error message if the tool call failed.\n     */\n    error?: string;\n}\n/**\n * jump targets (internal)\n */\nexport type JumpTo = \"model_request\" | \"tools\" | typeof END;\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}\nexport type CreateAgentParams<StructuredResponseType extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\n    /**\n     * Defines a model to use for the agent. You can either pass in an instance of a LangChain chat model\n     * or a string. If a string is provided the agent 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     * @example\n     * ```ts\n     * import { ChatOpenAI } from \"@langchain/openai\";\n     * const agent = createAgent({\n     *   model: new ChatOpenAI({ model: \"gpt-4o\" }),\n     *   // ...\n     * });\n     * ```\n     */\n    model: string | LanguageModelLike;\n    /**\n     * A list of tools or a ToolNode.\n     *\n     * @example\n     * ```ts\n     * import { tool } from \"langchain\";\n     *\n     * const weatherTool = tool(() => \"Sunny!\", {\n     *   name: \"get_weather\",\n     *   description: \"Get the weather for a location\",\n     *   schema: z.object({\n     *     location: z.string().describe(\"The location to get weather for\"),\n     *   }),\n     * });\n     *\n     * const agent = createAgent({\n     *   tools: [weatherTool],\n     *   // ...\n     * });\n     * ```\n     */\n    tools?: (ServerTool | ClientTool)[];\n    /**\n     * An optional system message for the model.\n     */\n    systemPrompt?: string;\n    /**\n     * An optional schema for the agent state. It allows you to define custom state properties that persist\n     * across agent invocations and can be accessed in hooks, middleware, and throughout the agent's execution.\n     * The state is persisted when using a checkpointer and can be updated by middleware or during execution.\n     *\n     * As opposed to the context (defined in `contextSchema`), the state is persisted between agent invocations\n     * when using a checkpointer, making it suitable for maintaining conversation history, user preferences,\n     * or any other data that should persist across multiple interactions.\n     *\n     * @example\n     * ```ts\n     * import { z } from \"zod\";\n     * import { createAgent } from \"@langchain/langgraph\";\n     *\n     * const agent = createAgent({\n     *   model: \"openai:gpt-4o\",\n     *   tools: [getWeather],\n     *   stateSchema: z.object({\n     *     userPreferences: z.object({\n     *       temperatureUnit: z.enum([\"celsius\", \"fahrenheit\"]).default(\"celsius\"),\n     *       location: z.string().optional(),\n     *     }).optional(),\n     *     conversationCount: z.number().default(0),\n     *   }),\n     *   prompt: (state, config) => {\n     *     const unit = state.userPreferences?.temperatureUnit || \"celsius\";\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. Use ${unit} for temperature.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new HumanMessage(\"What's the weather like?\"),\n     *   ],\n     *   userPreferences: {\n     *     temperatureUnit: \"fahrenheit\",\n     *     location: \"New York\",\n     *   },\n     *   conversationCount: 1,\n     * });\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` and middleware.\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    /**\n     * An optional checkpoint saver to persist the agent's state.\n     * @see {@link https://docs.langchain.com/oss/javascript/langgraph/persistence | Checkpointing}\n     */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /**\n     * An optional store to persist the agent's state.\n     * @see {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Long-term memory}\n     */\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     * Middleware instances to run during agent execution.\n     * Each middleware can define its own state schema and hook into the agent lifecycle.\n     *\n     * @see {@link https://docs.langchain.com/oss/javascript/langchain/middleware | Middleware}\n     */\n    middleware?: readonly AgentMiddleware<any, any, any>[];\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 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};\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;\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"],"mappings":";;;;;;;;;;;;KAWYsB,CAAAA,UAAWpB;AAAvB;AAIA;AAUA;AAA6B,UAVZqB,SAUY,CAAA,SAAA,OAAA,CAAA,CAAA;EAAA;;;EAWJ,EAAA,EAAA,MAAA;EAKbG;;;EAAgD,KAAG1B,EAlBpDwB,MAkBoDxB;;AAA4CkB,UAhB1FO,YAAAA,CAgB0FP;EAAgB,QAC7GT,EAhBAH,WAgBAG,EAAAA;EAAQ,aAAA,CAAA,EAfFc,SAeE,EAAA;EAKLK;AAyBjB;AAiBA;AAIA;AAkBA;;;;EAAyF,MAAmCX,CAAAA,EA3E/GI,YA2E+GJ;;;;;AAAkLiB,KAtElSR,SAsEkSQ,CAAAA,qBAtEnQjB,iBAsEmQiB,GAtE/OlC,gBAsE+OkC,GAAAA,SAAAA,GAAAA,SAAAA,CAAAA,GAtEnMhB,gBAsEmMgB,CAtElLP,YAsEkLO,CAAAA,GAAAA;EAAsB,QAArCjC,EArEjRQ,QAqEiRR;CAAc;;;;AAAkIiC,UAhE9ZN,UAAAA,CAgE8ZM;EAAsB;;;EAAgB,EAAA,EAA4CA,MAAAA;EAAsB;;;EAwBlf,IAsBxBf,EAAAA,MAAAA;EAAU;;;EAmFU,IAKdZ,EA1LTsB,MA0LStB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAAmB;;;EAkEG,MAoB5B+B,CAAAA,EAAAA,OAAAA;EAAW;AAiBxB;;EAAgC,KAAoBrC,CAAAA,EAAAA,MAAAA;;;;;AAAqIyC,UApRxKZ,UAAAA,CAoRwKY;EAAC;;;EAAiC,EAAA,EAAA,MAAA;EAC/MC;;;EAAoD,MAASvC,EAAAA,GAAAA;EAAU;;;EAAsF,KAAEkB,CAAAA,EAAAA,MAAAA;;;;;AAArBlB,KApQ1I2B,MAAAA,GAoQ0I3B,eAAAA,GAAAA,OAAAA,GAAAA,OApQ9FD,GAoQ8FC;AAAU;;;UAhQ/I4B,gBAAAA;;;;;;;;QAQPH;;;;;;;;;;KAUEI,iDAAiDJ,sBAAsBA,yCAAyCZ,oBAAoBjB,gEAAgEiB,oBAAoBjB,mBAAmBiB,wCAAwChB,eAAeiC,0BAA0BjC,4BAA4Ba,mBAAmBA,qBAAqBJ,iBAAiBE,kBAAkBsB,0BAA0BvB,aAAauB,0BAA0BrB,iBAAiBqB,0BAA0BnB;;;;;;;;;;;;;;;;;;;;;;;;kBAwBvgBV;;;;;;;;;;;;;;;;;;;;;;WAsBPc,aAAaC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAiDRe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkCEC;;;;;iBAKD7B;;;;;UAKPC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsDS6B;;;;;;;wBAOKrB;;;;;;;;;;;;;;;;;;;;WAoBbsB;;;;;;;;;;;;;;;;;KAiBDC,wCAAwCtC,yBAAyBuC,oBAAoBvC,0CAA0CwC,sBAAsBxC,wBAAwByC,IAAIH,qBAAqBE,QAAQC;KAC9MC,+CAA+CC,cAAcxC,6EAA6EA,WAAWyC,IAAIC,GAAGC,GAAGzB,IAAI0B,GAAGC,GAAGC,GAAGC"}