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

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":["InteropZodObject","InteropZodDefault","InteropZodOptional","InteropZodType","InferInteropZodInput","InferInteropZodOutput","LangGraphRunnableConfig","START","PregelOptions","Runtime","LangGraphRuntime","END","LanguageModelLike","BaseMessage","BaseCheckpointSaver","BaseStore","JUMP_TO_TARGETS","AnyAnnotationRoot","ToAnnotationRoot","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","JsonSchemaFormat","ResponseFormatUndefined","Interrupt","ToolNode","ClientTool","ServerTool","N","BuiltInState","JumpToTarget","ToolCall","Record","ToolResult","ModelRequest","IsOptionalZodObject","T","IsDefaultZodObject","WithMaybeContext","TContext","Omit","Partial","TState","Error","ControlAction","TStateSchema","MiddlewareResult","AgentBuiltInState","FilterPrivateProps","K","InferMiddlewareState","AgentMiddleware","S","InferMiddlewareInputState","InferMiddlewareStates","First","Rest","InferMiddlewareInputStates","InferMergedState","InferMergedInputState","InferMiddlewareContext","C","InferMiddlewareContextInput","Inner","InferMiddlewareContexts","MergeContextTypes","A","B","InferMiddlewareContextInputs","JumpTo","TSchema","TContextSchema","TFullContext","Promise","ExecutedToolCall","LLMCall","CreateAgentParams","StructuredResponseType","ContextSchema","ResponseFormatType","AbortSignal","IsOptionalType","ExtractNonUndefined","IsAllOptional","InferContextInput","IsDefaultContext","InferAgentConfig","TMiddleware","InternalAgentState","CreateAgentPregelOptions","InvokeConfiguration","Pick","StreamConfiguration"],"sources":["../../../src/agents/middlewareAgent/types.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { InteropZodObject, InteropZodDefault, InteropZodOptional, InteropZodType, InferInteropZodInput, InferInteropZodOutput } from \"@langchain/core/utils/types\";\nimport type { LangGraphRunnableConfig, START, PregelOptions, Runtime as LangGraphRuntime, END } 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 { JUMP_TO_TARGETS } from \"./constants.js\";\nimport type { AnyAnnotationRoot, ToAnnotationRoot } from \"../annotation.js\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, JsonSchemaFormat } from \"../responses.js\";\nimport type { ResponseFormatUndefined } from \"../annotation.js\";\nimport type { Interrupt } from \"../interrupt.js\";\nimport type { ToolNode } from \"../nodes/ToolNode.js\";\nimport type { ClientTool, ServerTool } from \"../types.js\";\nexport type N = typeof START | \"model_request\" | \"tools\";\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 * 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 * Configuration for modifying a model call at runtime.\n * All fields are optional and only provided fields will override defaults.\n */\nexport interface ModelRequest {\n    /**\n     * The model to use for this step.\n     */\n    model: LanguageModelLike;\n    /**\n     * The messages to send to the model.\n     */\n    messages: BaseMessage[];\n    /**\n     * The system message for this step.\n     */\n    systemPrompt?: string;\n    /**\n     * Tool choice configuration (model-specific format).\n     * Can be one of:\n     * - `\"auto\"`: means the model can pick between generating a message or calling one or more tools.\n     * - `\"none\"`: means the model will not call any tool and instead generates a message.\n     * - `\"required\"`: means the model must call one or more tools.\n     * - `{ type: \"function\", function: { name: string } }`: The model will use the specified function.\n     */\n    toolChoice?: \"auto\" | \"none\" | \"required\" | {\n        type: \"function\";\n        function: {\n            name: string;\n        };\n    };\n    /**\n     * The tools to make available for this step.\n     */\n    tools: string[];\n}\n/**\n * Type helper to check if TContext is an optional Zod schema\n */\ntype IsOptionalZodObject<T> = T extends InteropZodOptional<any> ? true : false;\ntype IsDefaultZodObject<T> = T extends InteropZodDefault<any> ? true : false;\nexport type WithMaybeContext<TContext> = undefined extends TContext ? {\n    readonly context?: TContext;\n} : IsOptionalZodObject<TContext> extends true ? {\n    readonly context?: TContext;\n} : IsDefaultZodObject<TContext> extends true ? {\n    readonly context?: TContext;\n} : {\n    readonly context: TContext;\n};\n/**\n * Runtime information available to middleware (readonly).\n */\nexport type Runtime<TState = unknown, TContext = unknown> = Partial<Omit<LangGraphRuntime<TContext>, \"context\" | \"configurable\">> & {\n    readonly toolCalls: ToolCall[];\n    /**\n     * All tool instances that are provided to the agent.\n     */\n    readonly tools: (ClientTool | ServerTool)[];\n    /**\n     * Terminates the agent with an update to the state or throws an error.\n     * @param result - The result to terminate the agent with.\n     */\n    terminate(result: Partial<TState> | Error): ControlAction<TState>;\n} & WithMaybeContext<TContext>;\n/**\n * Control action type returned by control methods.\n */\nexport type ControlAction<TStateSchema> = {\n    type: \"terminate\";\n    target?: string;\n    stateUpdate?: Partial<TStateSchema>;\n    result?: any;\n    error?: Error;\n};\n/**\n * Result type for middleware functions.\n */\nexport type MiddlewareResult<TState> = TState | void;\n/**\n * Type for the agent's built-in state properties.\n */\nexport type AgentBuiltInState = {\n    messages: BaseMessage[];\n};\n/**\n * Helper type to filter out properties that start with underscore (private properties)\n */\ntype FilterPrivateProps<T> = {\n    [K in keyof T as K extends `_${string}` ? never : K]: T[K];\n};\n/**\n * Helper type to infer the state schema type from a middleware\n * This filters out private properties (those starting with underscore)\n */\nexport type InferMiddlewareState<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<infer S, any, any> ? S extends InteropZodObject ? FilterPrivateProps<InferInteropZodOutput<S>> : {} : {};\n/**\n * Helper type to infer the input state schema type from a middleware (all properties optional)\n * This filters out private properties (those starting with underscore)\n */\nexport type InferMiddlewareInputState<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<infer S, any, any> ? S extends InteropZodObject ? FilterPrivateProps<InferInteropZodInput<S>> : {} : {};\n/**\n * Helper type to infer merged state from an array of middleware (just the middleware states)\n */\nexport type InferMiddlewareStates<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? InferMiddlewareState<First> & InferMiddlewareStates<Rest> : InferMiddlewareState<First> : {} : {};\n/**\n * Helper type to infer merged input state from an array of middleware (with optional defaults)\n */\nexport type InferMiddlewareInputStates<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? InferMiddlewareInputState<First> & InferMiddlewareInputStates<Rest> : InferMiddlewareInputState<First> : {} : {};\n/**\n * Helper type to infer merged state from an array of middleware (includes built-in state)\n */\nexport type InferMergedState<T extends readonly AgentMiddleware<any, any, any>[]> = InferMiddlewareStates<T> & AgentBuiltInState;\n/**\n * Helper type to infer merged input state from an array of middleware (includes built-in state)\n */\nexport type InferMergedInputState<T extends readonly AgentMiddleware<any, any, any>[]> = InferMiddlewareInputStates<T> & AgentBuiltInState;\n/**\n * Helper type to infer the context schema type from a middleware\n */\nexport type InferMiddlewareContext<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<any, infer C, any> ? C extends InteropZodObject ? InferInteropZodInput<C> : {} : {};\n/**\n * Helper type to infer the input context schema type from a middleware (with optional defaults)\n */\nexport type InferMiddlewareContextInput<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<any, infer C, any> ? C extends InteropZodOptional<infer Inner> ? InferInteropZodInput<Inner> | undefined : C extends InteropZodObject ? InferInteropZodInput<C> : {} : {};\n/**\n * Helper type to infer merged context from an array of middleware\n */\nexport type InferMiddlewareContexts<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? InferMiddlewareContext<First> & InferMiddlewareContexts<Rest> : InferMiddlewareContext<First> : {} : {};\n/**\n * Helper to merge two context types, preserving undefined unions\n */\ntype MergeContextTypes<A, B> = [A] extends [undefined] ? [B] extends [undefined] ? undefined : B | undefined : [B] extends [undefined] ? A | undefined : [A] extends [B] ? A : [B] extends [A] ? B : A & B;\n/**\n * Helper type to infer merged input context from an array of middleware (with optional defaults)\n */\nexport type InferMiddlewareContextInputs<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? MergeContextTypes<InferMiddlewareContextInput<First>, InferMiddlewareContextInputs<Rest>> : InferMiddlewareContextInput<First> : {} : {};\n/**\n * jump targets (user facing)\n */\nexport type JumpToTarget = (typeof JUMP_TO_TARGETS)[number];\n/**\n * jump targets (internal)\n */\nexport type JumpTo = \"model_request\" | \"tools\" | typeof END;\n/**\n * Base middleware interface.\n */\nexport interface AgentMiddleware<TSchema extends InteropZodObject | undefined = undefined, TContextSchema extends InteropZodObject | InteropZodDefault<InteropZodObject> | InteropZodOptional<InteropZodObject> | undefined = undefined, TFullContext = any> {\n    stateSchema?: TSchema;\n    contextSchema?: TContextSchema;\n    name: string;\n    beforeModelJumpTo?: JumpToTarget[];\n    afterModelJumpTo?: JumpToTarget[];\n    tools?: (ClientTool | ServerTool)[];\n    /**\n     * Runs before each LLM call, can modify call parameters, changes are not persistent\n     * e.g. if you change `model`, it will only be changed for the next model call\n     *\n     * @param options - Current call options (can be modified by previous middleware)\n     * @param state - Current state (read-only in this phase)\n     * @param runtime - Runtime context and metadata\n     * @returns Modified options or undefined to pass through\n     */\n    modifyModelRequest?(request: ModelRequest, state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<Partial<ModelRequest> | void> | Partial<ModelRequest> | void;\n    beforeModel?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;\n    afterModel?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;\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 * 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}\nexport type CreateAgentParams<StructuredResponseType extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\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?: 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 `modifyModelRequest`.\n     */\n    systemPrompt?: string;\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    /** 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    /**\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    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 * Helper type to check if a type is optional (includes undefined)\n */\ntype IsOptionalType<T> = undefined extends T ? true : false;\n/**\n * Extract non-undefined part of a union that includes undefined\n */\ntype ExtractNonUndefined<T> = T extends undefined ? never : T;\n/**\n * Helper type to check if all properties of a type are optional\n */\nexport type IsAllOptional<T> = \n// If T includes undefined, then it's optional (can be omitted entirely)\nundefined extends T ? true : IsOptionalType<T> extends true ? true : ExtractNonUndefined<T> extends Record<string, any> ? {} extends ExtractNonUndefined<T> ? true : false : IsOptionalType<T>;\n/**\n * Helper type to extract input type from context schema (with optional defaults)\n */\nexport type InferContextInput<ContextSchema extends AnyAnnotationRoot | InteropZodObject> = ContextSchema extends InteropZodObject ? InferInteropZodInput<ContextSchema> : ContextSchema extends AnyAnnotationRoot ? ToAnnotationRoot<ContextSchema>[\"State\"] : {};\n/**\n * Helper to check if ContextSchema is the default (AnyAnnotationRoot)\n */\ntype IsDefaultContext<T> = [T] extends [AnyAnnotationRoot] ? any extends T ? true : false : false;\n/**\n * Helper type to get the required config type based on context schema\n */\nexport type InferAgentConfig<ContextSchema extends AnyAnnotationRoot | InteropZodObject, TMiddleware extends readonly AgentMiddleware<any, any, any>[]> = IsDefaultContext<ContextSchema> extends true ? TMiddleware extends readonly [] ? LangGraphRunnableConfig | undefined // No middleware, no context needed\n : WithMaybeContext<InferMiddlewareContextInputs<TMiddleware>> extends {\n    readonly context?: any;\n} ? LangGraphRunnableConfig<{\n    context?: InferMiddlewareContextInputs<TMiddleware>;\n}> | undefined : LangGraphRunnableConfig<{\n    context: InferMiddlewareContextInputs<TMiddleware>;\n}> : WithMaybeContext<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> extends {\n    readonly context?: any;\n} ? LangGraphRunnableConfig<{\n    context?: InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>;\n}> | undefined : LangGraphRunnableConfig<{\n    context: InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>;\n}>;\nexport type InternalAgentState<StructuredResponseType extends Record<string, unknown> | undefined = Record<string, unknown>> = {\n    messages: BaseMessage[];\n    __preparedModelOptions?: ModelRequest;\n} & (StructuredResponseType extends ResponseFormatUndefined ? Record<string, never> : {\n    structuredResponse: StructuredResponseType;\n});\n/**\n * Pregel options that are propagated to the agent\n */\ntype CreateAgentPregelOptions = \"configurable\" | \"durability\" | \"store\" | \"cache\" | \"signal\" | \"recursionLimit\" | \"maxConcurrency\" | \"timeout\";\n/**\n * Decide whether provided configuration requires a context\n */\nexport type InvokeConfiguration<ContextSchema extends Record<string, any>> = \n/**\n * If the context schema is a default object, `context` can be optional\n */\nContextSchema extends InteropZodDefault<any> ? Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & {\n    context?: Partial<ContextSchema>;\n} : IsAllOptional<ContextSchema> extends true ? Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & {\n    context?: Partial<ContextSchema>;\n} : Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & WithMaybeContext<ContextSchema>;\nexport type StreamConfiguration<ContextSchema extends Record<string, any>> = \n/**\n * If the context schema is a default object, `context` can be optional\n */\nContextSchema extends InteropZodDefault<any> ? Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & {\n    context?: Partial<ContextSchema>;\n} : IsAllOptional<ContextSchema> extends true ? Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions | \"streamMode\">> & {\n    context?: Partial<ContextSchema>;\n} : Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions | \"streamMode\">> & WithMaybeContext<ContextSchema>;\nexport {};\n"],"mappings":"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"}
+{"version":3,"file":"types.d.ts","names":["InteropZodObject","InteropZodDefault","InteropZodOptional","InteropZodType","InferInteropZodInput","InferInteropZodOutput","LangGraphRunnableConfig","START","PregelOptions","Runtime","LangGraphRuntime","END","LanguageModelLike","BaseMessage","BaseCheckpointSaver","BaseStore","Messages","JUMP_TO_TARGETS","AnyAnnotationRoot","ToAnnotationRoot","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","JsonSchemaFormat","ResponseFormatUndefined","ToolNode","ClientTool","ServerTool","N","Interrupt","TValue","BuiltInState","JumpToTarget","UserInput","ToolCall","Record","ToolResult","ModelRequest","IsOptionalZodObject","T","IsDefaultZodObject","WithMaybeContext","TContext","Omit","Partial","PrivateState","MiddlewareResult","TState","AgentBuiltInState","FilterPrivateProps","K","InferMiddlewareState","AgentMiddleware","S","InferMiddlewareInputState","InferMiddlewareStates","First","Rest","InferMiddlewareInputStates","InferMergedState","InferMergedInputState","InferMiddlewareContext","C","InferMiddlewareContextInput","Inner","InferMiddlewareContexts","MergeContextTypes","A","B","InferMiddlewareContextInputs","JumpTo","TSchema","TContextSchema","TFullContext","Promise","Error","ExecutedToolCall","CreateAgentParams","StructuredResponseType","ContextSchema","ResponseFormatType","AbortSignal","IsOptionalType","ExtractNonUndefined","IsAllOptional","InferContextInput","IsDefaultContext","InferAgentConfig","TMiddleware","RunLevelPrivateState","ThreadLevelPrivateState","InternalAgentState","CreateAgentPregelOptions","InvokeConfiguration","Pick","StreamConfiguration"],"sources":["../../../src/agents/middlewareAgent/types.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { InteropZodObject, InteropZodDefault, InteropZodOptional, InteropZodType, InferInteropZodInput, InferInteropZodOutput } from \"@langchain/core/utils/types\";\nimport type { LangGraphRunnableConfig, START, PregelOptions, Runtime as LangGraphRuntime, END } 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 { JUMP_TO_TARGETS } from \"./constants.js\";\nimport type { AnyAnnotationRoot, ToAnnotationRoot } from \"../annotation.js\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, JsonSchemaFormat } from \"../responses.js\";\nimport type { ResponseFormatUndefined } from \"../annotation.js\";\nimport type { ToolNode } from \"../nodes/ToolNode.js\";\nimport type { ClientTool, ServerTool } from \"../types.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 = {\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 * Configuration for modifying a model call at runtime.\n * All fields are optional and only provided fields will override defaults.\n */\nexport interface ModelRequest {\n    /**\n     * The model to use for this step.\n     */\n    model: LanguageModelLike;\n    /**\n     * The messages to send to the model.\n     */\n    messages: BaseMessage[];\n    /**\n     * The system message for this step.\n     */\n    systemPrompt?: string;\n    /**\n     * Tool choice configuration (model-specific format).\n     * Can be one of:\n     * - `\"auto\"`: means the model can pick between generating a message or calling one or more tools.\n     * - `\"none\"`: means the model will not call any tool and instead generates a message.\n     * - `\"required\"`: means the model must call one or more tools.\n     * - `{ type: \"function\", function: { name: string } }`: The model will use the specified function.\n     */\n    toolChoice?: \"auto\" | \"none\" | \"required\" | {\n        type: \"function\";\n        function: {\n            name: string;\n        };\n    };\n    /**\n     * The tools to make available for this step.\n     */\n    tools: (ServerTool | ClientTool)[];\n}\n/**\n * Type helper to check if TContext is an optional Zod schema\n */\ntype IsOptionalZodObject<T> = T extends InteropZodOptional<any> ? true : false;\ntype IsDefaultZodObject<T> = T extends InteropZodDefault<any> ? true : false;\nexport type WithMaybeContext<TContext> = undefined extends TContext ? {\n    readonly context?: TContext;\n} : IsOptionalZodObject<TContext> extends true ? {\n    readonly context?: TContext;\n} : IsDefaultZodObject<TContext> extends true ? {\n    readonly context?: TContext;\n} : {\n    readonly context: TContext;\n};\n/**\n * Runtime information available to middleware (readonly).\n */\nexport type Runtime<TContext = unknown> = Partial<Omit<LangGraphRuntime<TContext>, \"context\" | \"configurable\">> & WithMaybeContext<TContext> & PrivateState;\n/**\n * Result type for middleware functions.\n */\nexport type MiddlewareResult<TState> = TState | void;\n/**\n * Type for the agent's built-in state properties.\n */\nexport type AgentBuiltInState = {\n    messages: BaseMessage[];\n};\n/**\n * Helper type to filter out properties that start with underscore (private properties)\n */\ntype FilterPrivateProps<T> = {\n    [K in keyof T as K extends `_${string}` ? never : K]: T[K];\n};\n/**\n * Helper type to infer the state schema type from a middleware\n * This filters out private properties (those starting with underscore)\n */\nexport type InferMiddlewareState<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<infer S, any, any> ? S extends InteropZodObject ? FilterPrivateProps<InferInteropZodOutput<S>> : {} : {};\n/**\n * Helper type to infer the input state schema type from a middleware (all properties optional)\n * This filters out private properties (those starting with underscore)\n */\nexport type InferMiddlewareInputState<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<infer S, any, any> ? S extends InteropZodObject ? FilterPrivateProps<InferInteropZodInput<S>> : {} : {};\n/**\n * Helper type to infer merged state from an array of middleware (just the middleware states)\n */\nexport type InferMiddlewareStates<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? InferMiddlewareState<First> & InferMiddlewareStates<Rest> : InferMiddlewareState<First> : {} : {};\n/**\n * Helper type to infer merged input state from an array of middleware (with optional defaults)\n */\nexport type InferMiddlewareInputStates<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? InferMiddlewareInputState<First> & InferMiddlewareInputStates<Rest> : InferMiddlewareInputState<First> : {} : {};\n/**\n * Helper type to infer merged state from an array of middleware (includes built-in state)\n */\nexport type InferMergedState<T extends readonly AgentMiddleware<any, any, any>[]> = InferMiddlewareStates<T> & AgentBuiltInState;\n/**\n * Helper type to infer merged input state from an array of middleware (includes built-in state)\n */\nexport type InferMergedInputState<T extends readonly AgentMiddleware<any, any, any>[]> = InferMiddlewareInputStates<T> & AgentBuiltInState;\n/**\n * Helper type to infer the context schema type from a middleware\n */\nexport type InferMiddlewareContext<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<any, infer C, any> ? C extends InteropZodObject ? InferInteropZodInput<C> : {} : {};\n/**\n * Helper type to infer the input context schema type from a middleware (with optional defaults)\n */\nexport type InferMiddlewareContextInput<T extends AgentMiddleware<any, any, any>> = T extends AgentMiddleware<any, infer C, any> ? C extends InteropZodOptional<infer Inner> ? InferInteropZodInput<Inner> | undefined : C extends InteropZodObject ? InferInteropZodInput<C> : {} : {};\n/**\n * Helper type to infer merged context from an array of middleware\n */\nexport type InferMiddlewareContexts<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? InferMiddlewareContext<First> & InferMiddlewareContexts<Rest> : InferMiddlewareContext<First> : {} : {};\n/**\n * Helper to merge two context types, preserving undefined unions\n */\ntype MergeContextTypes<A, B> = [A] extends [undefined] ? [B] extends [undefined] ? undefined : B | undefined : [B] extends [undefined] ? A | undefined : [A] extends [B] ? A : [B] extends [A] ? B : A & B;\n/**\n * Helper type to infer merged input context from an array of middleware (with optional defaults)\n */\nexport type InferMiddlewareContextInputs<T extends readonly AgentMiddleware<any, any, any>[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware<any, any, any> ? Rest extends readonly AgentMiddleware<any, any, any>[] ? MergeContextTypes<InferMiddlewareContextInput<First>, InferMiddlewareContextInputs<Rest>> : InferMiddlewareContextInput<First> : {} : {};\n/**\n * jump targets (user facing)\n */\nexport type JumpToTarget = (typeof JUMP_TO_TARGETS)[number];\n/**\n * jump targets (internal)\n */\nexport type JumpTo = \"model_request\" | \"tools\" | typeof END;\n/**\n * Base middleware interface.\n */\nexport interface AgentMiddleware<TSchema extends InteropZodObject | undefined = undefined, TContextSchema extends InteropZodObject | InteropZodDefault<InteropZodObject> | InteropZodOptional<InteropZodObject> | undefined = undefined, TFullContext = any> {\n    stateSchema?: TSchema;\n    contextSchema?: TContextSchema;\n    name: string;\n    beforeModelJumpTo?: JumpToTarget[];\n    afterModelJumpTo?: JumpToTarget[];\n    tools?: (ClientTool | ServerTool)[];\n    /**\n     * Runs before each LLM call, can modify call parameters, changes are not persistent\n     * e.g. if you change `model`, it will only be changed for the next model call\n     *\n     * @param options - Current call options (can be modified by previous middleware)\n     * @param state - Current state (read-only in this phase)\n     * @param runtime - Runtime context and metadata\n     * @returns Modified options or undefined to pass through\n     */\n    modifyModelRequest?(request: ModelRequest, state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<Partial<ModelRequest> | void> | Partial<ModelRequest> | void;\n    /**\n     * Logic to handle model invocation errors and optionally retry.\n     *\n     * @param error - The exception that occurred during model invocation.\n     * @param request - The original model request that failed.\n     * @param state - The current agent state.\n     * @param runtime - The runtime context.\n     * @param attempt - The current attempt number (1-indexed).\n     * @returns Modified request to retry with, or undefined/null to propagate the error (re-raise).\n     */\n    retryModelRequest?(error: Error, request: ModelRequest, state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>, attempt: number): Promise<ModelRequest | void> | ModelRequest | void;\n    beforeModel?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;\n    afterModel?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;\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}\nexport type CreateAgentParams<StructuredResponseType extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\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?: 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 `modifyModelRequest`.\n     */\n    systemPrompt?: string;\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    /** 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    /**\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    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 * Helper type to check if a type is optional (includes undefined)\n */\ntype IsOptionalType<T> = undefined extends T ? true : false;\n/**\n * Extract non-undefined part of a union that includes undefined\n */\ntype ExtractNonUndefined<T> = T extends undefined ? never : T;\n/**\n * Helper type to check if all properties of a type are optional\n */\nexport type IsAllOptional<T> = \n// If T includes undefined, then it's optional (can be omitted entirely)\nundefined extends T ? true : IsOptionalType<T> extends true ? true : ExtractNonUndefined<T> extends Record<string, any> ? {} extends ExtractNonUndefined<T> ? true : false : IsOptionalType<T>;\n/**\n * Helper type to extract input type from context schema (with optional defaults)\n */\nexport type InferContextInput<ContextSchema extends AnyAnnotationRoot | InteropZodObject> = ContextSchema extends InteropZodObject ? InferInteropZodInput<ContextSchema> : ContextSchema extends AnyAnnotationRoot ? ToAnnotationRoot<ContextSchema>[\"State\"] : {};\n/**\n * Helper to check if ContextSchema is the default (AnyAnnotationRoot)\n */\ntype IsDefaultContext<T> = [T] extends [AnyAnnotationRoot] ? any extends T ? true : false : false;\n/**\n * Helper type to get the required config type based on context schema\n */\nexport type InferAgentConfig<ContextSchema extends AnyAnnotationRoot | InteropZodObject, TMiddleware extends readonly AgentMiddleware<any, any, any>[]> = IsDefaultContext<ContextSchema> extends true ? TMiddleware extends readonly [] ? LangGraphRunnableConfig | undefined // No middleware, no context needed\n : WithMaybeContext<InferMiddlewareContextInputs<TMiddleware>> extends {\n    readonly context?: any;\n} ? LangGraphRunnableConfig<{\n    context?: InferMiddlewareContextInputs<TMiddleware>;\n}> | undefined : LangGraphRunnableConfig<{\n    context: InferMiddlewareContextInputs<TMiddleware>;\n}> : WithMaybeContext<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> extends {\n    readonly context?: any;\n} ? LangGraphRunnableConfig<{\n    context?: InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>;\n}> | undefined : LangGraphRunnableConfig<{\n    context: InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>;\n}>;\nexport interface RunLevelPrivateState {\n    /**\n     * The number of times the model has been called at the run level.\n     * This includes multiple agent invocations.\n     */\n    runModelCallCount: number;\n}\nexport interface ThreadLevelPrivateState {\n    /**\n     * The number of times the model has been called at the thread level.\n     * This includes multiple agent invocations within different environments\n     * using the same thread.\n     */\n    threadLevelCallCount: number;\n}\n/**\n * As private state we consider all information we want to track within\n * the lifecycle of the agent, without exposing it to the user. These informations\n * are propagated to the user as _readonly_ runtime properties.\n */\nexport interface PrivateState extends ThreadLevelPrivateState, RunLevelPrivateState {\n}\nexport type InternalAgentState<StructuredResponseType extends Record<string, unknown> | undefined = Record<string, unknown>> = {\n    messages: BaseMessage[];\n    _privateState?: PrivateState;\n} & (StructuredResponseType extends ResponseFormatUndefined ? Record<string, never> : {\n    structuredResponse: StructuredResponseType;\n});\n/**\n * Pregel options that are propagated to the agent\n */\ntype CreateAgentPregelOptions = \"configurable\" | \"durability\" | \"store\" | \"cache\" | \"signal\" | \"recursionLimit\" | \"maxConcurrency\" | \"timeout\";\n/**\n * Decide whether provided configuration requires a context\n */\nexport type InvokeConfiguration<ContextSchema extends Record<string, any>> = \n/**\n * If the context schema is a default object, `context` can be optional\n */\nContextSchema extends InteropZodDefault<any> ? Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & {\n    context?: Partial<ContextSchema>;\n} : IsAllOptional<ContextSchema> extends true ? Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & {\n    context?: Partial<ContextSchema>;\n} : Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & WithMaybeContext<ContextSchema>;\nexport type StreamConfiguration<ContextSchema extends Record<string, any>> = \n/**\n * If the context schema is a default object, `context` can be optional\n */\nContextSchema extends InteropZodDefault<any> ? Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & {\n    context?: Partial<ContextSchema>;\n} : IsAllOptional<ContextSchema> extends true ? Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions | \"streamMode\">> & {\n    context?: Partial<ContextSchema>;\n} : Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions | \"streamMode\">> & WithMaybeContext<ContextSchema>;\nexport {};\n"],"mappings":"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"}

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

@@ -1,8 +1,8 @@
 import { AnyAnnotationRoot, PreHookAnnotation, ToAnnotationRoot } from "../annotation.cjs";
 import { RunnableCallable } from "../RunnableCallable.cjs";
 import { InteropZodObject } from "@langchain/core/utils/types";
-import { Command } from "@langchain/langgraph";
 import { ToolMessage } from "@langchain/core/messages";
+import { Command } from "@langchain/langgraph";
 import { ToolCall } from "@langchain/core/messages/tool";
 import { RunnableConfig, RunnableToolLike } from "@langchain/core/runnables";
 import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";

package/dist/agents/tests/utils.cjs

@@ -0,0 +1,77 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
+const __langchain_core_language_models_chat_models = require_rolldown_runtime.__toESM(require("@langchain/core/language_models/chat_models"));
+const __langchain_core_runnables = require_rolldown_runtime.__toESM(require("@langchain/core/runnables"));
+const __langchain_core_tools = require_rolldown_runtime.__toESM(require("@langchain/core/tools"));
+const zod_v3 = require_rolldown_runtime.__toESM(require("zod/v3"));
+require("@langchain/langgraph-checkpoint");
+
+//#region src/agents/tests/utils.ts
+/**
+* Fake chat model for testing tool calling functionality
+*/
+var FakeToolCallingModel = class FakeToolCallingModel extends __langchain_core_language_models_chat_models.BaseChatModel {
+	toolCalls;
+	toolStyle;
+	index;
+	structuredResponse;
+	tools = [];
+	constructor({ toolCalls = [], toolStyle = "openai", index = 0, structuredResponse,...rest } = {}) {
+		super(rest);
+		this.toolCalls = toolCalls;
+		this.toolStyle = toolStyle;
+		this.index = index;
+		this.structuredResponse = structuredResponse;
+	}
+	_llmType() {
+		return "fake-tool-calling";
+	}
+	_combineLLMOutput() {
+		return [];
+	}
+	bindTools(tools) {
+		const newInstance = new FakeToolCallingModel({
+			toolCalls: this.toolCalls,
+			toolStyle: this.toolStyle,
+			index: this.index,
+			structuredResponse: this.structuredResponse
+		});
+		newInstance.tools = [...this.tools, ...tools];
+		return newInstance;
+	}
+	withStructuredOutput(_schema) {
+		return new __langchain_core_runnables.RunnableLambda({ func: async () => {
+			return this.structuredResponse;
+		} });
+	}
+	async _generate(messages, _options, _runManager) {
+		const lastMessage = messages[messages.length - 1];
+		let content = lastMessage.content;
+		if (messages.length > 1) {
+			const parts = messages.map((m) => m.content).filter(Boolean);
+			content = parts.join("-");
+		}
+		const currentToolCalls = this.toolCalls[this.index] || [];
+		const messageId = this.index.toString();
+		this.index = (this.index + 1) % Math.max(1, this.toolCalls.length);
+		const message = new __langchain_core_messages.AIMessage({
+			content,
+			id: messageId,
+			tool_calls: currentToolCalls.length > 0 ? currentToolCalls.map((tc) => ({
+				...tc,
+				type: "tool_call"
+			})) : void 0
+		});
+		return {
+			generations: [{
+				text: content,
+				message
+			}],
+			llmOutput: {}
+		};
+	}
+};
+
+//#endregion
+exports.FakeToolCallingModel = FakeToolCallingModel;
+//# sourceMappingURL=utils.cjs.map

package/dist/agents/tests/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","names":["BaseChatModel","tools: StructuredTool[]","_schema: any","RunnableLambda","messages: BaseMessage[]","_options?: this[\"ParsedCallOptions\"]","_runManager?: CallbackManagerForLLMRun","AIMessage"],"sources":["../../../src/agents/tests/utils.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable import/no-extraneous-dependencies */\nimport { expect } from \"vitest\";\nimport { CallbackManagerForLLMRun } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseChatModel,\n  BaseChatModelParams,\n  BaseChatModelCallOptions,\n  BindToolsInput,\n  ToolChoice,\n} from \"@langchain/core/language_models/chat_models\";\nimport { StructuredTool } from \"@langchain/core/tools\";\nimport {\n  BaseMessage,\n  AIMessage,\n  HumanMessage,\n  BaseMessageFields,\n  AIMessageFields,\n  ToolMessage,\n  ToolMessageFields,\n} from \"@langchain/core/messages\";\nimport { ChatResult } from \"@langchain/core/outputs\";\nimport {\n  Runnable,\n  RunnableConfig,\n  RunnableLambda,\n  RunnableBinding,\n} from \"@langchain/core/runnables\";\nimport {\n  MemorySaver,\n  Checkpoint,\n  CheckpointMetadata,\n  type BaseCheckpointSaver,\n} from \"@langchain/langgraph-checkpoint\";\nimport { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { z } from \"zod/v3\";\n\nexport class _AnyIdAIMessage extends AIMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"AIMessage\"];\n  }\n\n  constructor(fields: AIMessageFields | string) {\n    let fieldsWithJestMatcher: Partial<AIMessageFields> = {\n      id: expect.any(String) as unknown as string,\n    };\n    if (typeof fields === \"string\") {\n      fieldsWithJestMatcher = {\n        content: fields,\n        ...fieldsWithJestMatcher,\n      };\n    } else {\n      fieldsWithJestMatcher = {\n        ...fields,\n        ...fieldsWithJestMatcher,\n      };\n    }\n    super(fieldsWithJestMatcher as AIMessageFields);\n  }\n}\n\nexport class _AnyIdHumanMessage extends HumanMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"HumanMessage\"];\n  }\n\n  constructor(fields: BaseMessageFields | string) {\n    let fieldsWithJestMatcher: Partial<BaseMessageFields> = {\n      id: expect.any(String) as unknown as string,\n    };\n    if (typeof fields === \"string\") {\n      fieldsWithJestMatcher = {\n        content: fields,\n        ...fieldsWithJestMatcher,\n      };\n    } else {\n      fieldsWithJestMatcher = {\n        ...fields,\n        ...fieldsWithJestMatcher,\n      };\n    }\n    super(fieldsWithJestMatcher as BaseMessageFields);\n  }\n}\n\nexport class _AnyIdToolMessage extends ToolMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"ToolMessage\"];\n  }\n\n  constructor(fields: ToolMessageFields) {\n    const fieldsWithJestMatcher: Partial<ToolMessageFields> = {\n      id: expect.any(String) as unknown as string,\n      ...fields,\n    };\n    super(fieldsWithJestMatcher as ToolMessageFields);\n  }\n}\n\nexport class FakeConfigurableModel extends BaseChatModel {\n  _queuedMethodOperations: Record<string, any> = {};\n\n  _chatModel: LanguageModelLike;\n\n  constructor(\n    fields: {\n      model: LanguageModelLike;\n    } & BaseChatModelParams\n  ) {\n    super(fields);\n    this._chatModel = fields.model;\n  }\n\n  _llmType() {\n    return \"fake_configurable\";\n  }\n\n  async _generate(\n    _messages: BaseMessage[],\n    _options: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    throw new Error(\"Not implemented\");\n  }\n\n  async _model() {\n    return this._chatModel;\n  }\n\n  bindTools(tools: BindToolsInput[]) {\n    const modelWithTools = new FakeConfigurableModel({\n      model: (this._chatModel as FakeToolCallingChatModel).bindTools(tools),\n    });\n    modelWithTools._queuedMethodOperations.bindTools = tools;\n    return modelWithTools;\n  }\n}\n\nexport class FakeToolCallingChatModel extends BaseChatModel {\n  sleep?: number = 50;\n\n  responses?: BaseMessage[];\n\n  thrownErrorString?: string;\n\n  idx: number;\n\n  toolStyle: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\" = \"openai\";\n\n  structuredResponse?: Record<string, unknown>;\n\n  // Track messages passed to structured output calls\n  structuredOutputMessages: BaseMessage[][] = [];\n\n  constructor(\n    fields: {\n      sleep?: number;\n      responses?: BaseMessage[];\n      thrownErrorString?: string;\n      toolStyle?: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\";\n      structuredResponse?: Record<string, unknown>;\n    } & BaseChatModelParams\n  ) {\n    super(fields);\n    this.sleep = fields.sleep ?? this.sleep;\n    this.responses = fields.responses;\n    this.thrownErrorString = fields.thrownErrorString;\n    this.idx = 0;\n    this.toolStyle = fields.toolStyle ?? this.toolStyle;\n    this.structuredResponse = fields.structuredResponse;\n    this.structuredOutputMessages = [];\n  }\n\n  _llmType() {\n    return \"fake\";\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    _options: this[\"ParsedCallOptions\"],\n    runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    if (this.thrownErrorString) {\n      throw new Error(this.thrownErrorString);\n    }\n    if (this.sleep !== undefined) {\n      await new Promise((resolve) => setTimeout(resolve, this.sleep));\n    }\n    const responses = this.responses?.length ? this.responses : messages;\n    const msg = responses[this.idx % responses.length];\n    const generation: ChatResult = {\n      generations: [\n        {\n          text: \"\",\n          message: msg,\n        },\n      ],\n    };\n    this.idx += 1;\n\n    if (typeof msg.content === \"string\") {\n      await runManager?.handleLLMNewToken(msg.content);\n    }\n    return generation;\n  }\n\n  bindTools(tools: BindToolsInput[]): Runnable<any> {\n    const toolDicts = [];\n    const serverTools = [];\n    for (const tool of tools) {\n      if (!(\"name\" in tool)) {\n        serverTools.push(tool);\n        continue;\n      }\n\n      // NOTE: this is a simplified tool spec for testing purposes only\n      if (this.toolStyle === \"openai\") {\n        toolDicts.push({\n          type: \"function\",\n          function: {\n            name: tool.name,\n          },\n        });\n      } else if ([\"anthropic\", \"google\"].includes(this.toolStyle)) {\n        toolDicts.push({\n          name: tool.name,\n        });\n      } else if (this.toolStyle === \"bedrock\") {\n        toolDicts.push({\n          toolSpec: {\n            name: tool.name,\n          },\n        });\n      }\n    }\n    let toolsToBind: BindToolsInput[] = toolDicts;\n    if (this.toolStyle === \"google\") {\n      toolsToBind = [{ functionDeclarations: toolDicts }];\n    }\n    return this.bind({\n      tools: [...toolsToBind, ...serverTools],\n    } as BaseChatModelCallOptions);\n  }\n\n  withStructuredOutput<\n    RunOutput extends Record<string, any> = Record<string, any>\n  >(_: unknown): Runnable<any> {\n    if (!this.structuredResponse) {\n      throw new Error(\"No structured response provided\");\n    }\n    // Create a runnable that returns the proper structured format\n    return RunnableLambda.from(async (messages: BaseMessage[]) => {\n      if (this.sleep) {\n        await new Promise((resolve) => setTimeout(resolve, this.sleep));\n      }\n\n      // Store the messages that were sent to generate structured output\n      this.structuredOutputMessages.push([...messages]);\n\n      // Return in the format expected: { raw: BaseMessage, parsed: RunOutput }\n      return this.structuredResponse as RunOutput;\n    });\n  }\n}\n\nexport class MemorySaverAssertImmutable extends MemorySaver {\n  storageForCopies: Record<string, Record<string, Uint8Array>> = {};\n\n  constructor() {\n    super();\n    this.storageForCopies = {};\n  }\n\n  async put(\n    config: RunnableConfig,\n    checkpoint: Checkpoint,\n    metadata: CheckpointMetadata\n  ): Promise<RunnableConfig> {\n    const thread_id = config.configurable?.thread_id;\n    this.storageForCopies[thread_id] ??= {};\n\n    // assert checkpoint hasn't been modified since last written\n    const saved = await this.get(config);\n    if (saved) {\n      const savedId = saved.id;\n      if (this.storageForCopies[thread_id][savedId]) {\n        const loaded = await this.serde.loadsTyped(\n          \"json\",\n          this.storageForCopies[thread_id][savedId]\n        );\n\n        expect(\n          saved,\n          `Checkpoint [${savedId}] has been modified since last written`\n        ).toEqual(loaded);\n      }\n    }\n    const [, serializedCheckpoint] = await this.serde.dumpsTyped(checkpoint);\n    // save a copy of the checkpoint\n    this.storageForCopies[thread_id][checkpoint.id] = serializedCheckpoint;\n\n    return super.put(config, checkpoint, metadata);\n  }\n}\n\ninterface ToolCall {\n  name: string;\n  args: Record<string, any>;\n  id: string;\n  type?: \"tool_call\";\n}\n\ninterface FakeToolCallingModelFields {\n  toolCalls?: ToolCall[][];\n  toolStyle?: \"openai\" | \"anthropic\";\n  index?: number;\n  structuredResponse?: any;\n}\n\n// Helper function to create checkpointer\nexport function createCheckpointer(): BaseCheckpointSaver {\n  return new MemorySaver();\n}\n\n/**\n * Fake chat model for testing tool calling functionality\n */\nexport class FakeToolCallingModel extends BaseChatModel {\n  toolCalls: ToolCall[][];\n\n  toolStyle: \"openai\" | \"anthropic\";\n\n  index: number;\n\n  structuredResponse?: any;\n\n  private tools: StructuredTool[] = [];\n\n  constructor({\n    toolCalls = [],\n    toolStyle = \"openai\",\n    index = 0,\n    structuredResponse,\n    ...rest\n  }: FakeToolCallingModelFields = {}) {\n    super(rest);\n    this.toolCalls = toolCalls;\n    this.toolStyle = toolStyle;\n    this.index = index;\n    this.structuredResponse = structuredResponse;\n  }\n\n  _llmType(): string {\n    return \"fake-tool-calling\";\n  }\n\n  _combineLLMOutput() {\n    return [];\n  }\n\n  bindTools(\n    tools: StructuredTool[]\n  ):\n    | FakeToolCallingModel\n    | RunnableBinding<\n        any,\n        any,\n        any & { tool_choice?: ToolChoice | undefined }\n      > {\n    const newInstance = new FakeToolCallingModel({\n      toolCalls: this.toolCalls,\n      toolStyle: this.toolStyle,\n      index: this.index,\n      structuredResponse: this.structuredResponse,\n    });\n    newInstance.tools = [...this.tools, ...tools];\n    return newInstance;\n  }\n\n  withStructuredOutput(_schema: any) {\n    return new RunnableLambda({\n      func: async () => {\n        return this.structuredResponse;\n      },\n    });\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    _options?: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    const lastMessage = messages[messages.length - 1];\n    let content = lastMessage.content as string;\n\n    // Handle prompt concatenation\n    if (messages.length > 1) {\n      const parts = messages.map((m) => m.content as string).filter(Boolean);\n      content = parts.join(\"-\");\n    }\n\n    const currentToolCalls = this.toolCalls[this.index] || [];\n    const messageId = this.index.toString();\n\n    // Move to next set of tool calls for subsequent invocations\n    this.index = (this.index + 1) % Math.max(1, this.toolCalls.length);\n\n    const message = new AIMessage({\n      content,\n      id: messageId,\n      tool_calls:\n        currentToolCalls.length > 0\n          ? currentToolCalls.map((tc) => ({\n              ...tc,\n              type: \"tool_call\" as const,\n            }))\n          : undefined,\n    });\n\n    return {\n      generations: [\n        {\n          text: content,\n          message,\n        },\n      ],\n      llmOutput: {},\n    };\n  }\n}\n\nexport class SearchAPI extends StructuredTool {\n  name = \"search_api\";\n\n  description = \"A simple API that returns the input string.\";\n\n  schema = z.object({\n    query: z.string().describe(\"The query to search for.\"),\n  });\n\n  async _call(input: z.infer<typeof this.schema>) {\n    if (input?.query === \"error\") {\n      throw new Error(\"Error\");\n    }\n    return `result for ${input?.query}`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAuUA,IAAa,uBAAb,MAAa,6BAA6BA,2DAAc;CACtD;CAEA;CAEA;CAEA;CAEA,AAAQ,QAA0B,CAAE;CAEpC,YAAY,EACV,YAAY,CAAE,GACd,YAAY,UACZ,QAAQ,GACR,mBACA,GAAG,MACwB,GAAG,CAAE,GAAE;EAClC,MAAM,KAAK;EACX,KAAK,YAAY;EACjB,KAAK,YAAY;EACjB,KAAK,QAAQ;EACb,KAAK,qBAAqB;CAC3B;CAED,WAAmB;AACjB,SAAO;CACR;CAED,oBAAoB;AAClB,SAAO,CAAE;CACV;CAED,UACEC,OAOI;EACJ,MAAM,cAAc,IAAI,qBAAqB;GAC3C,WAAW,KAAK;GAChB,WAAW,KAAK;GAChB,OAAO,KAAK;GACZ,oBAAoB,KAAK;EAC1B;EACD,YAAY,QAAQ,CAAC,GAAG,KAAK,OAAO,GAAG,KAAM;AAC7C,SAAO;CACR;CAED,qBAAqBC,SAAc;AACjC,SAAO,IAAIC,0CAAe,EACxB,MAAM,YAAY;AAChB,UAAO,KAAK;EACb,EACF;CACF;CAED,MAAM,UACJC,UACAC,UACAC,aACqB;EACrB,MAAM,cAAc,SAAS,SAAS,SAAS;EAC/C,IAAI,UAAU,YAAY;AAG1B,MAAI,SAAS,SAAS,GAAG;GACvB,MAAM,QAAQ,SAAS,IAAI,CAAC,MAAM,EAAE,QAAkB,CAAC,OAAO,QAAQ;GACtE,UAAU,MAAM,KAAK,IAAI;EAC1B;EAED,MAAM,mBAAmB,KAAK,UAAU,KAAK,UAAU,CAAE;EACzD,MAAM,YAAY,KAAK,MAAM,UAAU;EAGvC,KAAK,SAAS,KAAK,QAAQ,KAAK,KAAK,IAAI,GAAG,KAAK,UAAU,OAAO;EAElE,MAAM,UAAU,IAAIC,oCAAU;GAC5B;GACA,IAAI;GACJ,YACE,iBAAiB,SAAS,IACtB,iBAAiB,IAAI,CAAC,QAAQ;IAC5B,GAAG;IACH,MAAM;GACP,GAAE,GACH;EACP;AAED,SAAO;GACL,aAAa,CACX;IACE,MAAM;IACN;GACD,CACF;GACD,WAAW,CAAE;EACd;CACF;AACF"}

package/dist/agents/tests/utils.d.cts

@@ -0,0 +1,53 @@
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+import { z } from "zod/v3";
+import { AIMessage, BaseMessage, ToolMessage } from "@langchain/core/messages";
+import { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+import { Runnable, RunnableBinding, RunnableConfig, RunnableLambda } from "@langchain/core/runnables";
+import { StructuredTool } from "@langchain/core/tools";
+import { BaseChatModel, BaseChatModelParams, BindToolsInput, ToolChoice } from "@langchain/core/language_models/chat_models";
+import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+import { ChatResult } from "@langchain/core/outputs";
+
+//#region src/agents/tests/utils.d.ts
+
+interface ToolCall {
+  name: string;
+  args: Record<string, any>;
+  id: string;
+  type?: "tool_call";
+}
+interface FakeToolCallingModelFields {
+  toolCalls?: ToolCall[][];
+  toolStyle?: "openai" | "anthropic";
+  index?: number;
+  structuredResponse?: any;
+}
+// Helper function to create checkpointer
+
+/**
+ * Fake chat model for testing tool calling functionality
+ */
+declare class FakeToolCallingModel extends BaseChatModel {
+  toolCalls: ToolCall[][];
+  toolStyle: "openai" | "anthropic";
+  index: number;
+  structuredResponse?: any;
+  private tools;
+  constructor({
+    toolCalls,
+    toolStyle,
+    index,
+    structuredResponse,
+    ...rest
+  }?: FakeToolCallingModelFields);
+  _llmType(): string;
+  _combineLLMOutput(): never[];
+  bindTools(tools: StructuredTool[]): FakeToolCallingModel | RunnableBinding<any, any, any & {
+    tool_choice?: ToolChoice | undefined;
+  }>;
+  withStructuredOutput(_schema: any): RunnableLambda<unknown, any, RunnableConfig<Record<string, any>>>;
+  _generate(messages: BaseMessage[], _options?: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+}
+//#endregion
+export { FakeToolCallingModel };
+//# sourceMappingURL=utils.d.cts.map

package/dist/agents/tests/utils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.cts","names":["CallbackManagerForLLMRun","BaseChatModel","BaseChatModelParams","BindToolsInput","ToolChoice","StructuredTool","BaseMessage","AIMessage","HumanMessage","BaseMessageFields","AIMessageFields","ToolMessage","ToolMessageFields","ChatResult","Runnable","RunnableConfig","RunnableLambda","RunnableBinding","MemorySaver","Checkpoint","CheckpointMetadata","BaseCheckpointSaver","LanguageModelLike","z","_AnyIdAIMessage","_AnyIdHumanMessage","_AnyIdToolMessage","FakeConfigurableModel","Record","Promise","FakeToolCallingChatModel","MemorySaverAssertImmutable","Uint8Array","ToolCall","FakeToolCallingModelFields","createCheckpointer","FakeToolCallingModel","toolCalls","toolStyle","index","structuredResponse","SearchAPI","ZodString","ZodTypeAny","ZodObject","this","schema","infer"],"sources":["../../../src/agents/tests/utils.d.ts"],"sourcesContent":["import { CallbackManagerForLLMRun } from \"@langchain/core/callbacks/manager\";\nimport { BaseChatModel, BaseChatModelParams, BindToolsInput, ToolChoice } from \"@langchain/core/language_models/chat_models\";\nimport { StructuredTool } from \"@langchain/core/tools\";\nimport { BaseMessage, AIMessage, HumanMessage, BaseMessageFields, AIMessageFields, ToolMessage, ToolMessageFields } from \"@langchain/core/messages\";\nimport { ChatResult } from \"@langchain/core/outputs\";\nimport { Runnable, RunnableConfig, RunnableLambda, RunnableBinding } from \"@langchain/core/runnables\";\nimport { MemorySaver, Checkpoint, CheckpointMetadata, type BaseCheckpointSaver } from \"@langchain/langgraph-checkpoint\";\nimport { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { z } from \"zod/v3\";\nexport declare class _AnyIdAIMessage extends AIMessage {\n    get lc_id(): string[];\n    constructor(fields: AIMessageFields | string);\n}\nexport declare class _AnyIdHumanMessage extends HumanMessage {\n    get lc_id(): string[];\n    constructor(fields: BaseMessageFields | string);\n}\nexport declare class _AnyIdToolMessage extends ToolMessage {\n    get lc_id(): string[];\n    constructor(fields: ToolMessageFields);\n}\nexport declare class FakeConfigurableModel extends BaseChatModel {\n    _queuedMethodOperations: Record<string, any>;\n    _chatModel: LanguageModelLike;\n    constructor(fields: {\n        model: LanguageModelLike;\n    } & BaseChatModelParams);\n    _llmType(): string;\n    _generate(_messages: BaseMessage[], _options: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n    _model(): Promise<LanguageModelLike>;\n    bindTools(tools: BindToolsInput[]): FakeConfigurableModel;\n}\nexport declare class FakeToolCallingChatModel extends BaseChatModel {\n    sleep?: number;\n    responses?: BaseMessage[];\n    thrownErrorString?: string;\n    idx: number;\n    toolStyle: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\";\n    structuredResponse?: Record<string, unknown>;\n    // Track messages passed to structured output calls\n    structuredOutputMessages: BaseMessage[][];\n    constructor(fields: {\n        sleep?: number;\n        responses?: BaseMessage[];\n        thrownErrorString?: string;\n        toolStyle?: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\";\n        structuredResponse?: Record<string, unknown>;\n    } & BaseChatModelParams);\n    _llmType(): string;\n    _generate(messages: BaseMessage[], _options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n    bindTools(tools: BindToolsInput[]): Runnable<any>;\n    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(_: unknown): Runnable<any>;\n}\nexport declare class MemorySaverAssertImmutable extends MemorySaver {\n    storageForCopies: Record<string, Record<string, Uint8Array>>;\n    constructor();\n    put(config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata): Promise<RunnableConfig>;\n}\ninterface ToolCall {\n    name: string;\n    args: Record<string, any>;\n    id: string;\n    type?: \"tool_call\";\n}\ninterface FakeToolCallingModelFields {\n    toolCalls?: ToolCall[][];\n    toolStyle?: \"openai\" | \"anthropic\";\n    index?: number;\n    structuredResponse?: any;\n}\n// Helper function to create checkpointer\nexport declare function createCheckpointer(): BaseCheckpointSaver;\n/**\n * Fake chat model for testing tool calling functionality\n */\nexport declare class FakeToolCallingModel extends BaseChatModel {\n    toolCalls: ToolCall[][];\n    toolStyle: \"openai\" | \"anthropic\";\n    index: number;\n    structuredResponse?: any;\n    private tools;\n    constructor({ toolCalls, toolStyle, index, structuredResponse, ...rest }?: FakeToolCallingModelFields);\n    _llmType(): string;\n    _combineLLMOutput(): never[];\n    bindTools(tools: StructuredTool[]): FakeToolCallingModel | RunnableBinding<any, any, any & {\n        tool_choice?: ToolChoice | undefined;\n    }>;\n    withStructuredOutput(_schema: any): RunnableLambda<unknown, any, RunnableConfig<Record<string, any>>>;\n    _generate(messages: BaseMessage[], _options?: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n}\nexport declare class SearchAPI extends StructuredTool {\n    name: string;\n    description: string;\n    schema: z.ZodObject<{\n        query: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        query: string;\n    }, {\n        query: string;\n    }>;\n    _call(input: z.infer<typeof this.schema>): Promise<string>;\n}\nexport {};\n"],"mappings":";;;;;;;;;;;;UA0DUiC,QAAAA;;QAEAL;;;;UAIAM,0BAAAA;cACMD;;;;;;;;;;cAUKG,oBAAAA,SAA6BnC,aAAAA;aACnCgC;;;;;;;;;;;MAKgEC;;;mBAG1D7B,mBAAmB+B,uBAAuBnB;kBACzCb;;sCAEkBY,6BAA6BD,eAAea;sBAC5DtB,mEAAmEN,2BAA2B6B,QAAQhB"}

package/dist/agents/tests/utils.d.ts

@@ -0,0 +1,53 @@
+import { AIMessage, BaseMessage, HumanMessage, ToolMessage } from "@langchain/core/messages";
+import { BaseChatModel, BaseChatModelParams, BindToolsInput, ToolChoice } from "@langchain/core/language_models/chat_models";
+import { Runnable, RunnableBinding, RunnableConfig, RunnableLambda } from "@langchain/core/runnables";
+import { StructuredTool } from "@langchain/core/tools";
+import { z } from "zod/v3";
+import { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+import { ChatResult } from "@langchain/core/outputs";
+import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+
+//#region src/agents/tests/utils.d.ts
+
+interface ToolCall {
+  name: string;
+  args: Record<string, any>;
+  id: string;
+  type?: "tool_call";
+}
+interface FakeToolCallingModelFields {
+  toolCalls?: ToolCall[][];
+  toolStyle?: "openai" | "anthropic";
+  index?: number;
+  structuredResponse?: any;
+}
+// Helper function to create checkpointer
+
+/**
+ * Fake chat model for testing tool calling functionality
+ */
+declare class FakeToolCallingModel extends BaseChatModel {
+  toolCalls: ToolCall[][];
+  toolStyle: "openai" | "anthropic";
+  index: number;
+  structuredResponse?: any;
+  private tools;
+  constructor({
+    toolCalls,
+    toolStyle,
+    index,
+    structuredResponse,
+    ...rest
+  }?: FakeToolCallingModelFields);
+  _llmType(): string;
+  _combineLLMOutput(): never[];
+  bindTools(tools: StructuredTool[]): FakeToolCallingModel | RunnableBinding<any, any, any & {
+    tool_choice?: ToolChoice | undefined;
+  }>;
+  withStructuredOutput(_schema: any): RunnableLambda<unknown, any, RunnableConfig<Record<string, any>>>;
+  _generate(messages: BaseMessage[], _options?: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+}
+//#endregion
+export { FakeToolCallingModel };
+//# sourceMappingURL=utils.d.ts.map

package/dist/agents/tests/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","names":["CallbackManagerForLLMRun","BaseChatModel","BaseChatModelParams","BindToolsInput","ToolChoice","StructuredTool","BaseMessage","AIMessage","HumanMessage","BaseMessageFields","AIMessageFields","ToolMessage","ToolMessageFields","ChatResult","Runnable","RunnableConfig","RunnableLambda","RunnableBinding","MemorySaver","Checkpoint","CheckpointMetadata","BaseCheckpointSaver","LanguageModelLike","z","_AnyIdAIMessage","_AnyIdHumanMessage","_AnyIdToolMessage","FakeConfigurableModel","Record","Promise","FakeToolCallingChatModel","MemorySaverAssertImmutable","Uint8Array","ToolCall","FakeToolCallingModelFields","createCheckpointer","FakeToolCallingModel","toolCalls","toolStyle","index","structuredResponse","SearchAPI","ZodString","ZodTypeAny","ZodObject","this","schema","infer"],"sources":["../../../src/agents/tests/utils.d.ts"],"sourcesContent":["import { CallbackManagerForLLMRun } from \"@langchain/core/callbacks/manager\";\nimport { BaseChatModel, BaseChatModelParams, BindToolsInput, ToolChoice } from \"@langchain/core/language_models/chat_models\";\nimport { StructuredTool } from \"@langchain/core/tools\";\nimport { BaseMessage, AIMessage, HumanMessage, BaseMessageFields, AIMessageFields, ToolMessage, ToolMessageFields } from \"@langchain/core/messages\";\nimport { ChatResult } from \"@langchain/core/outputs\";\nimport { Runnable, RunnableConfig, RunnableLambda, RunnableBinding } from \"@langchain/core/runnables\";\nimport { MemorySaver, Checkpoint, CheckpointMetadata, type BaseCheckpointSaver } from \"@langchain/langgraph-checkpoint\";\nimport { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { z } from \"zod/v3\";\nexport declare class _AnyIdAIMessage extends AIMessage {\n    get lc_id(): string[];\n    constructor(fields: AIMessageFields | string);\n}\nexport declare class _AnyIdHumanMessage extends HumanMessage {\n    get lc_id(): string[];\n    constructor(fields: BaseMessageFields | string);\n}\nexport declare class _AnyIdToolMessage extends ToolMessage {\n    get lc_id(): string[];\n    constructor(fields: ToolMessageFields);\n}\nexport declare class FakeConfigurableModel extends BaseChatModel {\n    _queuedMethodOperations: Record<string, any>;\n    _chatModel: LanguageModelLike;\n    constructor(fields: {\n        model: LanguageModelLike;\n    } & BaseChatModelParams);\n    _llmType(): string;\n    _generate(_messages: BaseMessage[], _options: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n    _model(): Promise<LanguageModelLike>;\n    bindTools(tools: BindToolsInput[]): FakeConfigurableModel;\n}\nexport declare class FakeToolCallingChatModel extends BaseChatModel {\n    sleep?: number;\n    responses?: BaseMessage[];\n    thrownErrorString?: string;\n    idx: number;\n    toolStyle: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\";\n    structuredResponse?: Record<string, unknown>;\n    // Track messages passed to structured output calls\n    structuredOutputMessages: BaseMessage[][];\n    constructor(fields: {\n        sleep?: number;\n        responses?: BaseMessage[];\n        thrownErrorString?: string;\n        toolStyle?: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\";\n        structuredResponse?: Record<string, unknown>;\n    } & BaseChatModelParams);\n    _llmType(): string;\n    _generate(messages: BaseMessage[], _options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n    bindTools(tools: BindToolsInput[]): Runnable<any>;\n    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(_: unknown): Runnable<any>;\n}\nexport declare class MemorySaverAssertImmutable extends MemorySaver {\n    storageForCopies: Record<string, Record<string, Uint8Array>>;\n    constructor();\n    put(config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata): Promise<RunnableConfig>;\n}\ninterface ToolCall {\n    name: string;\n    args: Record<string, any>;\n    id: string;\n    type?: \"tool_call\";\n}\ninterface FakeToolCallingModelFields {\n    toolCalls?: ToolCall[][];\n    toolStyle?: \"openai\" | \"anthropic\";\n    index?: number;\n    structuredResponse?: any;\n}\n// Helper function to create checkpointer\nexport declare function createCheckpointer(): BaseCheckpointSaver;\n/**\n * Fake chat model for testing tool calling functionality\n */\nexport declare class FakeToolCallingModel extends BaseChatModel {\n    toolCalls: ToolCall[][];\n    toolStyle: \"openai\" | \"anthropic\";\n    index: number;\n    structuredResponse?: any;\n    private tools;\n    constructor({ toolCalls, toolStyle, index, structuredResponse, ...rest }?: FakeToolCallingModelFields);\n    _llmType(): string;\n    _combineLLMOutput(): never[];\n    bindTools(tools: StructuredTool[]): FakeToolCallingModel | RunnableBinding<any, any, any & {\n        tool_choice?: ToolChoice | undefined;\n    }>;\n    withStructuredOutput(_schema: any): RunnableLambda<unknown, any, RunnableConfig<Record<string, any>>>;\n    _generate(messages: BaseMessage[], _options?: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n}\nexport declare class SearchAPI extends StructuredTool {\n    name: string;\n    description: string;\n    schema: z.ZodObject<{\n        query: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        query: string;\n    }, {\n        query: string;\n    }>;\n    _call(input: z.infer<typeof this.schema>): Promise<string>;\n}\nexport {};\n"],"mappings":";;;;;;;;;;;;UA0DUiC,QAAAA;;QAEAL;;;;UAIAM,0BAAAA;cACMD;;;;;;;;;;cAUKG,oBAAAA,SAA6BnC,aAAAA;aACnCgC;;;;;;;;;;;MAKgEC;;;mBAG1D7B,mBAAmB+B,uBAAuBnB;kBACzCb;;sCAEkBY,6BAA6BD,eAAea;sBAC5DtB,mEAAmEN,2BAA2B6B,QAAQhB"}

package/dist/agents/tests/utils.js

@@ -0,0 +1,76 @@
+import { AIMessage, HumanMessage, ToolMessage } from "@langchain/core/messages";
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { RunnableLambda } from "@langchain/core/runnables";
+import { StructuredTool } from "@langchain/core/tools";
+import { z } from "zod/v3";
+import "@langchain/langgraph-checkpoint";
+
+//#region src/agents/tests/utils.ts
+/**
+* Fake chat model for testing tool calling functionality
+*/
+var FakeToolCallingModel = class FakeToolCallingModel extends BaseChatModel {
+	toolCalls;
+	toolStyle;
+	index;
+	structuredResponse;
+	tools = [];
+	constructor({ toolCalls = [], toolStyle = "openai", index = 0, structuredResponse,...rest } = {}) {
+		super(rest);
+		this.toolCalls = toolCalls;
+		this.toolStyle = toolStyle;
+		this.index = index;
+		this.structuredResponse = structuredResponse;
+	}
+	_llmType() {
+		return "fake-tool-calling";
+	}
+	_combineLLMOutput() {
+		return [];
+	}
+	bindTools(tools) {
+		const newInstance = new FakeToolCallingModel({
+			toolCalls: this.toolCalls,
+			toolStyle: this.toolStyle,
+			index: this.index,
+			structuredResponse: this.structuredResponse
+		});
+		newInstance.tools = [...this.tools, ...tools];
+		return newInstance;
+	}
+	withStructuredOutput(_schema) {
+		return new RunnableLambda({ func: async () => {
+			return this.structuredResponse;
+		} });
+	}
+	async _generate(messages, _options, _runManager) {
+		const lastMessage = messages[messages.length - 1];
+		let content = lastMessage.content;
+		if (messages.length > 1) {
+			const parts = messages.map((m) => m.content).filter(Boolean);
+			content = parts.join("-");
+		}
+		const currentToolCalls = this.toolCalls[this.index] || [];
+		const messageId = this.index.toString();
+		this.index = (this.index + 1) % Math.max(1, this.toolCalls.length);
+		const message = new AIMessage({
+			content,
+			id: messageId,
+			tool_calls: currentToolCalls.length > 0 ? currentToolCalls.map((tc) => ({
+				...tc,
+				type: "tool_call"
+			})) : void 0
+		});
+		return {
+			generations: [{
+				text: content,
+				message
+			}],
+			llmOutput: {}
+		};
+	}
+};
+
+//#endregion
+export { FakeToolCallingModel };
+//# sourceMappingURL=utils.js.map

package/dist/agents/tests/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["tools: StructuredTool[]","_schema: any","messages: BaseMessage[]","_options?: this[\"ParsedCallOptions\"]","_runManager?: CallbackManagerForLLMRun"],"sources":["../../../src/agents/tests/utils.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable import/no-extraneous-dependencies */\nimport { expect } from \"vitest\";\nimport { CallbackManagerForLLMRun } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseChatModel,\n  BaseChatModelParams,\n  BaseChatModelCallOptions,\n  BindToolsInput,\n  ToolChoice,\n} from \"@langchain/core/language_models/chat_models\";\nimport { StructuredTool } from \"@langchain/core/tools\";\nimport {\n  BaseMessage,\n  AIMessage,\n  HumanMessage,\n  BaseMessageFields,\n  AIMessageFields,\n  ToolMessage,\n  ToolMessageFields,\n} from \"@langchain/core/messages\";\nimport { ChatResult } from \"@langchain/core/outputs\";\nimport {\n  Runnable,\n  RunnableConfig,\n  RunnableLambda,\n  RunnableBinding,\n} from \"@langchain/core/runnables\";\nimport {\n  MemorySaver,\n  Checkpoint,\n  CheckpointMetadata,\n  type BaseCheckpointSaver,\n} from \"@langchain/langgraph-checkpoint\";\nimport { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { z } from \"zod/v3\";\n\nexport class _AnyIdAIMessage extends AIMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"AIMessage\"];\n  }\n\n  constructor(fields: AIMessageFields | string) {\n    let fieldsWithJestMatcher: Partial<AIMessageFields> = {\n      id: expect.any(String) as unknown as string,\n    };\n    if (typeof fields === \"string\") {\n      fieldsWithJestMatcher = {\n        content: fields,\n        ...fieldsWithJestMatcher,\n      };\n    } else {\n      fieldsWithJestMatcher = {\n        ...fields,\n        ...fieldsWithJestMatcher,\n      };\n    }\n    super(fieldsWithJestMatcher as AIMessageFields);\n  }\n}\n\nexport class _AnyIdHumanMessage extends HumanMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"HumanMessage\"];\n  }\n\n  constructor(fields: BaseMessageFields | string) {\n    let fieldsWithJestMatcher: Partial<BaseMessageFields> = {\n      id: expect.any(String) as unknown as string,\n    };\n    if (typeof fields === \"string\") {\n      fieldsWithJestMatcher = {\n        content: fields,\n        ...fieldsWithJestMatcher,\n      };\n    } else {\n      fieldsWithJestMatcher = {\n        ...fields,\n        ...fieldsWithJestMatcher,\n      };\n    }\n    super(fieldsWithJestMatcher as BaseMessageFields);\n  }\n}\n\nexport class _AnyIdToolMessage extends ToolMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"ToolMessage\"];\n  }\n\n  constructor(fields: ToolMessageFields) {\n    const fieldsWithJestMatcher: Partial<ToolMessageFields> = {\n      id: expect.any(String) as unknown as string,\n      ...fields,\n    };\n    super(fieldsWithJestMatcher as ToolMessageFields);\n  }\n}\n\nexport class FakeConfigurableModel extends BaseChatModel {\n  _queuedMethodOperations: Record<string, any> = {};\n\n  _chatModel: LanguageModelLike;\n\n  constructor(\n    fields: {\n      model: LanguageModelLike;\n    } & BaseChatModelParams\n  ) {\n    super(fields);\n    this._chatModel = fields.model;\n  }\n\n  _llmType() {\n    return \"fake_configurable\";\n  }\n\n  async _generate(\n    _messages: BaseMessage[],\n    _options: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    throw new Error(\"Not implemented\");\n  }\n\n  async _model() {\n    return this._chatModel;\n  }\n\n  bindTools(tools: BindToolsInput[]) {\n    const modelWithTools = new FakeConfigurableModel({\n      model: (this._chatModel as FakeToolCallingChatModel).bindTools(tools),\n    });\n    modelWithTools._queuedMethodOperations.bindTools = tools;\n    return modelWithTools;\n  }\n}\n\nexport class FakeToolCallingChatModel extends BaseChatModel {\n  sleep?: number = 50;\n\n  responses?: BaseMessage[];\n\n  thrownErrorString?: string;\n\n  idx: number;\n\n  toolStyle: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\" = \"openai\";\n\n  structuredResponse?: Record<string, unknown>;\n\n  // Track messages passed to structured output calls\n  structuredOutputMessages: BaseMessage[][] = [];\n\n  constructor(\n    fields: {\n      sleep?: number;\n      responses?: BaseMessage[];\n      thrownErrorString?: string;\n      toolStyle?: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\";\n      structuredResponse?: Record<string, unknown>;\n    } & BaseChatModelParams\n  ) {\n    super(fields);\n    this.sleep = fields.sleep ?? this.sleep;\n    this.responses = fields.responses;\n    this.thrownErrorString = fields.thrownErrorString;\n    this.idx = 0;\n    this.toolStyle = fields.toolStyle ?? this.toolStyle;\n    this.structuredResponse = fields.structuredResponse;\n    this.structuredOutputMessages = [];\n  }\n\n  _llmType() {\n    return \"fake\";\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    _options: this[\"ParsedCallOptions\"],\n    runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    if (this.thrownErrorString) {\n      throw new Error(this.thrownErrorString);\n    }\n    if (this.sleep !== undefined) {\n      await new Promise((resolve) => setTimeout(resolve, this.sleep));\n    }\n    const responses = this.responses?.length ? this.responses : messages;\n    const msg = responses[this.idx % responses.length];\n    const generation: ChatResult = {\n      generations: [\n        {\n          text: \"\",\n          message: msg,\n        },\n      ],\n    };\n    this.idx += 1;\n\n    if (typeof msg.content === \"string\") {\n      await runManager?.handleLLMNewToken(msg.content);\n    }\n    return generation;\n  }\n\n  bindTools(tools: BindToolsInput[]): Runnable<any> {\n    const toolDicts = [];\n    const serverTools = [];\n    for (const tool of tools) {\n      if (!(\"name\" in tool)) {\n        serverTools.push(tool);\n        continue;\n      }\n\n      // NOTE: this is a simplified tool spec for testing purposes only\n      if (this.toolStyle === \"openai\") {\n        toolDicts.push({\n          type: \"function\",\n          function: {\n            name: tool.name,\n          },\n        });\n      } else if ([\"anthropic\", \"google\"].includes(this.toolStyle)) {\n        toolDicts.push({\n          name: tool.name,\n        });\n      } else if (this.toolStyle === \"bedrock\") {\n        toolDicts.push({\n          toolSpec: {\n            name: tool.name,\n          },\n        });\n      }\n    }\n    let toolsToBind: BindToolsInput[] = toolDicts;\n    if (this.toolStyle === \"google\") {\n      toolsToBind = [{ functionDeclarations: toolDicts }];\n    }\n    return this.bind({\n      tools: [...toolsToBind, ...serverTools],\n    } as BaseChatModelCallOptions);\n  }\n\n  withStructuredOutput<\n    RunOutput extends Record<string, any> = Record<string, any>\n  >(_: unknown): Runnable<any> {\n    if (!this.structuredResponse) {\n      throw new Error(\"No structured response provided\");\n    }\n    // Create a runnable that returns the proper structured format\n    return RunnableLambda.from(async (messages: BaseMessage[]) => {\n      if (this.sleep) {\n        await new Promise((resolve) => setTimeout(resolve, this.sleep));\n      }\n\n      // Store the messages that were sent to generate structured output\n      this.structuredOutputMessages.push([...messages]);\n\n      // Return in the format expected: { raw: BaseMessage, parsed: RunOutput }\n      return this.structuredResponse as RunOutput;\n    });\n  }\n}\n\nexport class MemorySaverAssertImmutable extends MemorySaver {\n  storageForCopies: Record<string, Record<string, Uint8Array>> = {};\n\n  constructor() {\n    super();\n    this.storageForCopies = {};\n  }\n\n  async put(\n    config: RunnableConfig,\n    checkpoint: Checkpoint,\n    metadata: CheckpointMetadata\n  ): Promise<RunnableConfig> {\n    const thread_id = config.configurable?.thread_id;\n    this.storageForCopies[thread_id] ??= {};\n\n    // assert checkpoint hasn't been modified since last written\n    const saved = await this.get(config);\n    if (saved) {\n      const savedId = saved.id;\n      if (this.storageForCopies[thread_id][savedId]) {\n        const loaded = await this.serde.loadsTyped(\n          \"json\",\n          this.storageForCopies[thread_id][savedId]\n        );\n\n        expect(\n          saved,\n          `Checkpoint [${savedId}] has been modified since last written`\n        ).toEqual(loaded);\n      }\n    }\n    const [, serializedCheckpoint] = await this.serde.dumpsTyped(checkpoint);\n    // save a copy of the checkpoint\n    this.storageForCopies[thread_id][checkpoint.id] = serializedCheckpoint;\n\n    return super.put(config, checkpoint, metadata);\n  }\n}\n\ninterface ToolCall {\n  name: string;\n  args: Record<string, any>;\n  id: string;\n  type?: \"tool_call\";\n}\n\ninterface FakeToolCallingModelFields {\n  toolCalls?: ToolCall[][];\n  toolStyle?: \"openai\" | \"anthropic\";\n  index?: number;\n  structuredResponse?: any;\n}\n\n// Helper function to create checkpointer\nexport function createCheckpointer(): BaseCheckpointSaver {\n  return new MemorySaver();\n}\n\n/**\n * Fake chat model for testing tool calling functionality\n */\nexport class FakeToolCallingModel extends BaseChatModel {\n  toolCalls: ToolCall[][];\n\n  toolStyle: \"openai\" | \"anthropic\";\n\n  index: number;\n\n  structuredResponse?: any;\n\n  private tools: StructuredTool[] = [];\n\n  constructor({\n    toolCalls = [],\n    toolStyle = \"openai\",\n    index = 0,\n    structuredResponse,\n    ...rest\n  }: FakeToolCallingModelFields = {}) {\n    super(rest);\n    this.toolCalls = toolCalls;\n    this.toolStyle = toolStyle;\n    this.index = index;\n    this.structuredResponse = structuredResponse;\n  }\n\n  _llmType(): string {\n    return \"fake-tool-calling\";\n  }\n\n  _combineLLMOutput() {\n    return [];\n  }\n\n  bindTools(\n    tools: StructuredTool[]\n  ):\n    | FakeToolCallingModel\n    | RunnableBinding<\n        any,\n        any,\n        any & { tool_choice?: ToolChoice | undefined }\n      > {\n    const newInstance = new FakeToolCallingModel({\n      toolCalls: this.toolCalls,\n      toolStyle: this.toolStyle,\n      index: this.index,\n      structuredResponse: this.structuredResponse,\n    });\n    newInstance.tools = [...this.tools, ...tools];\n    return newInstance;\n  }\n\n  withStructuredOutput(_schema: any) {\n    return new RunnableLambda({\n      func: async () => {\n        return this.structuredResponse;\n      },\n    });\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    _options?: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    const lastMessage = messages[messages.length - 1];\n    let content = lastMessage.content as string;\n\n    // Handle prompt concatenation\n    if (messages.length > 1) {\n      const parts = messages.map((m) => m.content as string).filter(Boolean);\n      content = parts.join(\"-\");\n    }\n\n    const currentToolCalls = this.toolCalls[this.index] || [];\n    const messageId = this.index.toString();\n\n    // Move to next set of tool calls for subsequent invocations\n    this.index = (this.index + 1) % Math.max(1, this.toolCalls.length);\n\n    const message = new AIMessage({\n      content,\n      id: messageId,\n      tool_calls:\n        currentToolCalls.length > 0\n          ? currentToolCalls.map((tc) => ({\n              ...tc,\n              type: \"tool_call\" as const,\n            }))\n          : undefined,\n    });\n\n    return {\n      generations: [\n        {\n          text: content,\n          message,\n        },\n      ],\n      llmOutput: {},\n    };\n  }\n}\n\nexport class SearchAPI extends StructuredTool {\n  name = \"search_api\";\n\n  description = \"A simple API that returns the input string.\";\n\n  schema = z.object({\n    query: z.string().describe(\"The query to search for.\"),\n  });\n\n  async _call(input: z.infer<typeof this.schema>) {\n    if (input?.query === \"error\") {\n      throw new Error(\"Error\");\n    }\n    return `result for ${input?.query}`;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAuUA,IAAa,uBAAb,MAAa,6BAA6B,cAAc;CACtD;CAEA;CAEA;CAEA;CAEA,AAAQ,QAA0B,CAAE;CAEpC,YAAY,EACV,YAAY,CAAE,GACd,YAAY,UACZ,QAAQ,GACR,mBACA,GAAG,MACwB,GAAG,CAAE,GAAE;EAClC,MAAM,KAAK;EACX,KAAK,YAAY;EACjB,KAAK,YAAY;EACjB,KAAK,QAAQ;EACb,KAAK,qBAAqB;CAC3B;CAED,WAAmB;AACjB,SAAO;CACR;CAED,oBAAoB;AAClB,SAAO,CAAE;CACV;CAED,UACEA,OAOI;EACJ,MAAM,cAAc,IAAI,qBAAqB;GAC3C,WAAW,KAAK;GAChB,WAAW,KAAK;GAChB,OAAO,KAAK;GACZ,oBAAoB,KAAK;EAC1B;EACD,YAAY,QAAQ,CAAC,GAAG,KAAK,OAAO,GAAG,KAAM;AAC7C,SAAO;CACR;CAED,qBAAqBC,SAAc;AACjC,SAAO,IAAI,eAAe,EACxB,MAAM,YAAY;AAChB,UAAO,KAAK;EACb,EACF;CACF;CAED,MAAM,UACJC,UACAC,UACAC,aACqB;EACrB,MAAM,cAAc,SAAS,SAAS,SAAS;EAC/C,IAAI,UAAU,YAAY;AAG1B,MAAI,SAAS,SAAS,GAAG;GACvB,MAAM,QAAQ,SAAS,IAAI,CAAC,MAAM,EAAE,QAAkB,CAAC,OAAO,QAAQ;GACtE,UAAU,MAAM,KAAK,IAAI;EAC1B;EAED,MAAM,mBAAmB,KAAK,UAAU,KAAK,UAAU,CAAE;EACzD,MAAM,YAAY,KAAK,MAAM,UAAU;EAGvC,KAAK,SAAS,KAAK,QAAQ,KAAK,KAAK,IAAI,GAAG,KAAK,UAAU,OAAO;EAElE,MAAM,UAAU,IAAI,UAAU;GAC5B;GACA,IAAI;GACJ,YACE,iBAAiB,SAAS,IACtB,iBAAiB,IAAI,CAAC,QAAQ;IAC5B,GAAG;IACH,MAAM;GACP,GAAE,GACH;EACP;AAED,SAAO;GACL,aAAa,CACX;IACE,MAAM;IACN;GACD,CACF;GACD,WAAW,CAAE;EACd;CACF;AACF"}

package/dist/agents/types.cjs

@@ -0,0 +1,7 @@
+
+//#region src/agents/types.ts
+const META_EXTRAS_DESCRIPTION_PREFIX = "lg:";
+
+//#endregion
+exports.META_EXTRAS_DESCRIPTION_PREFIX = META_EXTRAS_DESCRIPTION_PREFIX;
+//# sourceMappingURL=types.cjs.map

package/dist/agents/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","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"}