langchain 1.0.0-alpha.2 → 1.0.0-alpha.3

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

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

package/dist/evaluation/agents/trajectory.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"trajectory.d.cts","names":["StructuredToolInterface","BaseLLMOutputParser","AgentStep","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","BaseChatModel","AgentTrajectoryEvaluator","EvalOutputType","LLMEvalChainInput","LLMTrajectoryEvaluatorArgs","ExtractLLMCallOptions","TrajectoryOutputParser","Promise","TrajectoryEvalChain","____________langchain_core_dist_prompt_values_js1","BasePromptValueInterface","Omit","Partial"],"sources":["../../../src/evaluation/agents/trajectory.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentTrajectoryEvaluator, EvalOutputType, LLMEvalChainInput, LLMTrajectoryEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\n/**\n * A parser for the output of the TrajectoryEvalChain.\n */\nexport declare class TrajectoryOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\n/**\n * A chain for evaluating ReAct style agents.\n *\n * This chain is used to evaluate ReAct style agents by reasoning about\n * the sequence of actions taken and their outcomes.\n */\nexport declare class TrajectoryEvalChain extends AgentTrajectoryEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    outputParser: TrajectoryOutputParser;\n    static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, import(\"../../../../langchain-core/dist/prompt_values.js\").BasePromptValueInterface, any>;\n    /**\n     * Get the description of the agent tools.\n     *\n     * @returns The description of the agent tools.\n     */\n    static toolsDescription(agentTools: StructuredToolInterface[]): string;\n    /**\n     * Create a new TrajectoryEvalChain.\n     * @param llm\n     * @param agentTools - The tools used by the agent.\n     * @param chainOptions - The options for the chain.\n     */\n    static fromLLM(llm: BaseChatModel, agentTools?: StructuredToolInterface[], chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<TrajectoryEvalChain>;\n    _prepareOutput(result: ChainValues): any;\n    /**\n     * Get the agent trajectory as a formatted string.\n     *\n     * @param steps - The agent trajectory.\n     * @returns The formatted agent trajectory.\n     */\n    getAgentTrajectory(steps: AgentStep[]): string;\n    formatReference(reference?: string): string;\n    _evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAYqBe,cAAAA,sBAAAA,SAA+Bd,mBAAT,CAA6BU,cAA7B,CAAA,CAAA;EAAA,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAAA,YAA6BA,EAAAA,MAAAA,EAAAA;EAAc,WAGzDN,CAAAA,WAAAA,EAAAA,UAAAA,EAAAA,GAAeD,cAAfC,EAAAA,EAAAA,UAAAA,EAA6CE,SAA7CF,GAAAA,SAAAA,CAAAA,EAAqEW,OAArEX,CAA6EM,cAA7EN,CAAAA;;;;;;AAH0C;AAWvE;AAAwC,cAAnBY,mBAAAA,SAA4BP,wBAAAA,CAAT;EAAA,OAMtBK,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsB,aACIT,CAAAA,EAAAA,MAAAA;EAAkB,cAA2BN,CAAAA,EAAAA,MAAAA;EAAuB,aAAA,EAAA,OAAA;EAAgH,iBAA3GM,EAAAA,OAAAA;EAAkB,YAM/FN,EAPtBe,sBAOsBf;EAAuB,OAOvCS,uBAAAA,CAAAA,MAAAA,CAAAA,EAboBH,kBAapBG,GAAAA,SAAAA,EAAAA,UAAAA,CAAAA,EAbiET,uBAajES,EAAAA,CAAAA,EAb6FH,kBAa7FG,CAAAA,GAAAA,EAbwF,wBAAA,EAaxFA,GAAAA,CAAAA;EAAa;;;;;EAA8H,OAA3BO,gBAAAA,CAAAA,UAAAA,EAPhGhB,uBAOgGgB,EAAAA,CAAAA,EAAAA,MAAAA;EAAO;;;;;;EAUQ,OAAWb,OAAAA,CAAAA,GAAAA,EAV1IM,aAU0IN,EAAAA,UAAAA,CAAAA,EAV9GH,uBAU8GG,EAAAA,EAAAA,YAAAA,CAAAA,EAVpEkB,OAUoElB,CAV5DiB,IAU4DjB,CAVvDS,iBAUuDT,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAV1Ba,OAU0Bb,CAVlBc,mBAUkBd,CAAAA;EAAW,cAAnBa,CAAAA,MAAAA,EAT/Hb,WAS+Ha,CAAAA,EAAAA,GAAAA;EAAO;AA9BxF;;;;;4BA4B3Cd;;iCAEKW,yCAAyCC,6CAA6CP,YAAYC,qBAAqBQ,QAAQb"}
+{"version":3,"file":"trajectory.d.cts","names":["StructuredToolInterface","BaseLLMOutputParser","AgentStep","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","BaseChatModel","AgentTrajectoryEvaluator","EvalOutputType","LLMEvalChainInput","LLMTrajectoryEvaluatorArgs","ExtractLLMCallOptions","TrajectoryOutputParser","Promise","TrajectoryEvalChain","____________langchain_core_dist_prompt_values_js0","BasePromptValueInterface","Omit","Partial"],"sources":["../../../src/evaluation/agents/trajectory.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentTrajectoryEvaluator, EvalOutputType, LLMEvalChainInput, LLMTrajectoryEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\n/**\n * A parser for the output of the TrajectoryEvalChain.\n */\nexport declare class TrajectoryOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\n/**\n * A chain for evaluating ReAct style agents.\n *\n * This chain is used to evaluate ReAct style agents by reasoning about\n * the sequence of actions taken and their outcomes.\n */\nexport declare class TrajectoryEvalChain extends AgentTrajectoryEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    outputParser: TrajectoryOutputParser;\n    static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, import(\"../../../../langchain-core/dist/prompt_values.js\").BasePromptValueInterface, any>;\n    /**\n     * Get the description of the agent tools.\n     *\n     * @returns The description of the agent tools.\n     */\n    static toolsDescription(agentTools: StructuredToolInterface[]): string;\n    /**\n     * Create a new TrajectoryEvalChain.\n     * @param llm\n     * @param agentTools - The tools used by the agent.\n     * @param chainOptions - The options for the chain.\n     */\n    static fromLLM(llm: BaseChatModel, agentTools?: StructuredToolInterface[], chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<TrajectoryEvalChain>;\n    _prepareOutput(result: ChainValues): any;\n    /**\n     * Get the agent trajectory as a formatted string.\n     *\n     * @param steps - The agent trajectory.\n     * @returns The formatted agent trajectory.\n     */\n    getAgentTrajectory(steps: AgentStep[]): string;\n    formatReference(reference?: string): string;\n    _evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAYqBe,cAAAA,sBAAAA,SAA+Bd,mBAAT,CAA6BU,cAA7B,CAAA,CAAA;EAAA,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAAA,YAA6BA,EAAAA,MAAAA,EAAAA;EAAc,WAGzDN,CAAAA,WAAAA,EAAAA,UAAAA,EAAAA,GAAeD,cAAfC,EAAAA,EAAAA,UAAAA,EAA6CE,SAA7CF,GAAAA,SAAAA,CAAAA,EAAqEW,OAArEX,CAA6EM,cAA7EN,CAAAA;;;;;;AAH0C;AAWvE;AAAwC,cAAnBY,mBAAAA,SAA4BP,wBAAAA,CAAT;EAAA,OAMtBK,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsB,aACIT,CAAAA,EAAAA,MAAAA;EAAkB,cAA2BN,CAAAA,EAAAA,MAAAA;EAAuB,aAAA,EAAA,OAAA;EAAgH,iBAA3GM,EAAAA,OAAAA;EAAkB,YAM/FN,EAPtBe,sBAOsBf;EAAuB,OAOvCS,uBAAAA,CAAAA,MAAAA,CAAAA,EAboBH,kBAapBG,GAAAA,SAAAA,EAAAA,UAAAA,CAAAA,EAbiET,uBAajES,EAAAA,CAAAA,EAb6FH,kBAa7FG,CAAAA,GAAAA,EAbwF,wBAAA,EAaxFA,GAAAA,CAAAA;EAAa;;;;;EAA8H,OAA3BO,gBAAAA,CAAAA,UAAAA,EAPhGhB,uBAOgGgB,EAAAA,CAAAA,EAAAA,MAAAA;EAAO;;;;;;EAUQ,OAAWb,OAAAA,CAAAA,GAAAA,EAV1IM,aAU0IN,EAAAA,UAAAA,CAAAA,EAV9GH,uBAU8GG,EAAAA,EAAAA,YAAAA,CAAAA,EAVpEkB,OAUoElB,CAV5DiB,IAU4DjB,CAVvDS,iBAUuDT,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAV1Ba,OAU0Bb,CAVlBc,mBAUkBd,CAAAA;EAAW,cAAnBa,CAAAA,MAAAA,EAT/Hb,WAS+Ha,CAAAA,EAAAA,GAAAA;EAAO;AA9BxF;;;;;4BA4B3Cd;;iCAEKW,yCAAyCC,6CAA6CP,YAAYC,qBAAqBQ,QAAQb"}

package/dist/index.cjs

@@ -13,22 +13,29 @@ const __langchain_core_context = require_rolldown_runtime.__toESM(require("@lang
 var src_exports = {};
 require_rolldown_runtime.__export(src_exports, {
 	AIMessage: () => __langchain_core_messages.AIMessage,
+	AIMessageChunk: () => __langchain_core_messages.AIMessageChunk,
 	BaseMessage: () => __langchain_core_messages.BaseMessage,
+	BaseMessageChunk: () => __langchain_core_messages.BaseMessageChunk,
 	Document: () => __langchain_core_documents.Document,
 	DynamicStructuredTool: () => __langchain_core_tools.DynamicStructuredTool,
 	HumanMessage: () => __langchain_core_messages.HumanMessage,
+	HumanMessageChunk: () => __langchain_core_messages.HumanMessageChunk,
 	InMemoryStore: () => __langchain_langgraph.InMemoryStore,
 	MemorySaver: () => __langchain_langgraph.MemorySaver,
 	SystemMessage: () => __langchain_core_messages.SystemMessage,
+	SystemMessageChunk: () => __langchain_core_messages.SystemMessageChunk,
 	ToolMessage: () => __langchain_core_messages.ToolMessage,
+	ToolMessageChunk: () => __langchain_core_messages.ToolMessageChunk,
 	ToolNode: () => require_ToolNode.ToolNode,
 	createReactAgent: () => require_index.createReactAgent,
+	filterMessages: () => __langchain_core_messages.filterMessages,
 	getContextVariable: () => __langchain_core_context.getContextVariable,
 	initChatModel: () => require_chat_models_universal.initChatModel,
 	providerStrategy: () => require_responses.providerStrategy,
 	setContextVariable: () => __langchain_core_context.setContextVariable,
 	tool: () => __langchain_core_tools.tool,
-	toolStrategy: () => require_responses.toolStrategy
+	toolStrategy: () => require_responses.toolStrategy,
+	trimMessages: () => __langchain_core_messages.trimMessages
 });
 
 //#endregion
@@ -38,12 +45,24 @@ Object.defineProperty(exports, 'AIMessage', {
     return __langchain_core_messages.AIMessage;
   }
 });
+Object.defineProperty(exports, 'AIMessageChunk', {
+  enumerable: true,
+  get: function () {
+    return __langchain_core_messages.AIMessageChunk;
+  }
+});
 Object.defineProperty(exports, 'BaseMessage', {
   enumerable: true,
   get: function () {
     return __langchain_core_messages.BaseMessage;
   }
 });
+Object.defineProperty(exports, 'BaseMessageChunk', {
+  enumerable: true,
+  get: function () {
+    return __langchain_core_messages.BaseMessageChunk;
+  }
+});
 Object.defineProperty(exports, 'Document', {
   enumerable: true,
   get: function () {
@@ -62,6 +81,12 @@ Object.defineProperty(exports, 'HumanMessage', {
     return __langchain_core_messages.HumanMessage;
   }
 });
+Object.defineProperty(exports, 'HumanMessageChunk', {
+  enumerable: true,
+  get: function () {
+    return __langchain_core_messages.HumanMessageChunk;
+  }
+});
 Object.defineProperty(exports, 'InMemoryStore', {
   enumerable: true,
   get: function () {
@@ -80,14 +105,32 @@ Object.defineProperty(exports, 'SystemMessage', {
     return __langchain_core_messages.SystemMessage;
   }
 });
+Object.defineProperty(exports, 'SystemMessageChunk', {
+  enumerable: true,
+  get: function () {
+    return __langchain_core_messages.SystemMessageChunk;
+  }
+});
 Object.defineProperty(exports, 'ToolMessage', {
   enumerable: true,
   get: function () {
     return __langchain_core_messages.ToolMessage;
   }
 });
+Object.defineProperty(exports, 'ToolMessageChunk', {
+  enumerable: true,
+  get: function () {
+    return __langchain_core_messages.ToolMessageChunk;
+  }
+});
 exports.ToolNode = require_ToolNode.ToolNode;
 exports.createReactAgent = require_index.createReactAgent;
+Object.defineProperty(exports, 'filterMessages', {
+  enumerable: true,
+  get: function () {
+    return __langchain_core_messages.filterMessages;
+  }
+});
 Object.defineProperty(exports, 'getContextVariable', {
   enumerable: true,
   get: function () {
@@ -115,4 +158,10 @@ Object.defineProperty(exports, 'tool', {
   }
 });
 exports.toolStrategy = require_responses.toolStrategy;
+Object.defineProperty(exports, 'trimMessages', {
+  enumerable: true,
+  get: function () {
+    return __langchain_core_messages.trimMessages;
+  }
+});
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * LangChain Messages\n */\nexport {\n  BaseMessage,\n  AIMessage,\n  SystemMessage,\n  HumanMessage,\n  ToolMessage,\n} from \"@langchain/core/messages\";\n\n/**\n * Universal Chat Model\n */\nexport { initChatModel } from \"./chat_models/universal.js\";\n\n/**\n * LangChain Tools\n */\nexport { tool, DynamicStructuredTool } from \"@langchain/core/tools\";\n\n/**\n * LangChain Agents\n */\nexport {\n  createReactAgent,\n  toolStrategy,\n  providerStrategy,\n  ToolNode,\n  type AgentState,\n  type HumanInterrupt,\n  type HumanInterruptConfig,\n  type ActionRequest,\n  type HumanResponse,\n} from \"./agents/index.js\";\n\n/**\n * LangChain Memory\n * Check in what we want to export here\n */\nexport { MemorySaver, InMemoryStore } from \"@langchain/langgraph\";\n\n/**\n * LangChain Context\n */\nexport {\n  setContextVariable,\n  getContextVariable,\n} from \"@langchain/core/context\";\n\n/**\n * LangChain Documents\n */\nexport { Document } from \"@langchain/core/documents\";\n"],"mappings":""}
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * LangChain Messages\n */\nexport {\n  BaseMessage,\n  BaseMessageChunk,\n  AIMessage,\n  AIMessageChunk,\n  SystemMessage,\n  SystemMessageChunk,\n  HumanMessage,\n  HumanMessageChunk,\n  ToolMessage,\n  ToolMessageChunk,\n  type ContentBlock,\n  filterMessages,\n  trimMessages,\n} from \"@langchain/core/messages\";\n\n/**\n * Universal Chat Model\n */\nexport { initChatModel } from \"./chat_models/universal.js\";\n\n/**\n * LangChain Tools\n */\nexport { tool, DynamicStructuredTool } from \"@langchain/core/tools\";\n\n/**\n * LangChain Agents\n */\nexport {\n  createReactAgent,\n  toolStrategy,\n  providerStrategy,\n  ToolNode,\n  type AgentState,\n  type AgentRuntime,\n  type HumanInterrupt,\n  type HumanInterruptConfig,\n  type ActionRequest,\n  type HumanResponse,\n} from \"./agents/index.js\";\n\n/**\n * LangChain Memory\n * Check in what we want to export here\n */\nexport { MemorySaver, InMemoryStore } from \"@langchain/langgraph\";\n\n/**\n * LangChain Context\n */\nexport {\n  setContextVariable,\n  getContextVariable,\n} from \"@langchain/core/context\";\n\n/**\n * LangChain Documents\n */\nexport { Document } from \"@langchain/core/documents\";\n"],"mappings":""}

package/dist/index.d.cts

@@ -1,12 +1,12 @@
 import { initChatModel } from "./chat_models/universal.cjs";
 import { providerStrategy, toolStrategy } from "./agents/responses.cjs";
 import { ToolNode } from "./agents/nodes/ToolNode.cjs";
-import { AgentState } from "./agents/types.cjs";
+import { AgentRuntime, AgentState } from "./agents/types.cjs";
 import { ActionRequest, HumanInterrupt, HumanInterruptConfig, HumanResponse } from "./agents/interrupt.cjs";
 import { createReactAgent } from "./agents/index.cjs";
 import { Document } from "@langchain/core/documents";
-import { AIMessage, BaseMessage, HumanMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
+import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ContentBlock, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, filterMessages, trimMessages } from "@langchain/core/messages";
 import { DynamicStructuredTool, tool } from "@langchain/core/tools";
 import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
 import { getContextVariable, setContextVariable } from "@langchain/core/context";
-export { AIMessage, type ActionRequest, type AgentState, BaseMessage, Document, DynamicStructuredTool, type HumanInterrupt, type HumanInterruptConfig, HumanMessage, type HumanResponse, InMemoryStore, MemorySaver, SystemMessage, ToolMessage, ToolNode, createReactAgent, getContextVariable, initChatModel, providerStrategy, setContextVariable, tool, toolStrategy };
+export { AIMessage, AIMessageChunk, type ActionRequest, type AgentRuntime, type AgentState, BaseMessage, BaseMessageChunk, type ContentBlock, Document, DynamicStructuredTool, type HumanInterrupt, type HumanInterruptConfig, HumanMessage, HumanMessageChunk, type HumanResponse, InMemoryStore, MemorySaver, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, ToolNode, createReactAgent, filterMessages, getContextVariable, initChatModel, providerStrategy, setContextVariable, tool, toolStrategy, trimMessages };

package/dist/index.d.ts

@@ -1,12 +1,12 @@
 import { initChatModel } from "./chat_models/universal.js";
 import { providerStrategy, toolStrategy } from "./agents/responses.js";
 import { ToolNode } from "./agents/nodes/ToolNode.js";
-import { AgentState } from "./agents/types.js";
+import { AgentRuntime, AgentState } from "./agents/types.js";
 import { ActionRequest, HumanInterrupt, HumanInterruptConfig, HumanResponse } from "./agents/interrupt.js";
 import { createReactAgent } from "./agents/index.js";
 import { Document } from "@langchain/core/documents";
-import { AIMessage, BaseMessage, HumanMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
+import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ContentBlock, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, filterMessages, trimMessages } from "@langchain/core/messages";
 import { DynamicStructuredTool, tool } from "@langchain/core/tools";
 import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
 import { getContextVariable, setContextVariable } from "@langchain/core/context";
-export { AIMessage, type ActionRequest, type AgentState, BaseMessage, Document, DynamicStructuredTool, type HumanInterrupt, type HumanInterruptConfig, HumanMessage, type HumanResponse, InMemoryStore, MemorySaver, SystemMessage, ToolMessage, ToolNode, createReactAgent, getContextVariable, initChatModel, providerStrategy, setContextVariable, tool, toolStrategy };
+export { AIMessage, AIMessageChunk, type ActionRequest, type AgentRuntime, type AgentState, BaseMessage, BaseMessageChunk, type ContentBlock, Document, DynamicStructuredTool, type HumanInterrupt, type HumanInterruptConfig, HumanMessage, HumanMessageChunk, type HumanResponse, InMemoryStore, MemorySaver, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, ToolNode, createReactAgent, filterMessages, getContextVariable, initChatModel, providerStrategy, setContextVariable, tool, toolStrategy, trimMessages };

package/dist/index.js

@@ -4,7 +4,7 @@ import { providerStrategy, toolStrategy } from "./agents/responses.js";
 import { ToolNode } from "./agents/nodes/ToolNode.js";
 import { createReactAgent } from "./agents/index.js";
 import { Document } from "@langchain/core/documents";
-import { AIMessage, BaseMessage, HumanMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
+import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, filterMessages, trimMessages } from "@langchain/core/messages";
 import { DynamicStructuredTool, tool } from "@langchain/core/tools";
 import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
 import { getContextVariable, setContextVariable } from "@langchain/core/context";
@@ -13,24 +13,31 @@ import { getContextVariable, setContextVariable } from "@langchain/core/context"
 var src_exports = {};
 __export(src_exports, {
 	AIMessage: () => AIMessage,
+	AIMessageChunk: () => AIMessageChunk,
 	BaseMessage: () => BaseMessage,
+	BaseMessageChunk: () => BaseMessageChunk,
 	Document: () => Document,
 	DynamicStructuredTool: () => DynamicStructuredTool,
 	HumanMessage: () => HumanMessage,
+	HumanMessageChunk: () => HumanMessageChunk,
 	InMemoryStore: () => InMemoryStore,
 	MemorySaver: () => MemorySaver,
 	SystemMessage: () => SystemMessage,
+	SystemMessageChunk: () => SystemMessageChunk,
 	ToolMessage: () => ToolMessage,
+	ToolMessageChunk: () => ToolMessageChunk,
 	ToolNode: () => ToolNode,
 	createReactAgent: () => createReactAgent,
+	filterMessages: () => filterMessages,
 	getContextVariable: () => getContextVariable,
 	initChatModel: () => initChatModel,
 	providerStrategy: () => providerStrategy,
 	setContextVariable: () => setContextVariable,
 	tool: () => tool,
-	toolStrategy: () => toolStrategy
+	toolStrategy: () => toolStrategy,
+	trimMessages: () => trimMessages
 });
 
 //#endregion
-export { AIMessage, BaseMessage, Document, DynamicStructuredTool, HumanMessage, InMemoryStore, MemorySaver, SystemMessage, ToolMessage, ToolNode, createReactAgent, getContextVariable, initChatModel, providerStrategy, setContextVariable, src_exports, tool, toolStrategy };
+export { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, Document, DynamicStructuredTool, HumanMessage, HumanMessageChunk, InMemoryStore, MemorySaver, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, ToolNode, createReactAgent, filterMessages, getContextVariable, initChatModel, providerStrategy, setContextVariable, src_exports, tool, toolStrategy, trimMessages };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * LangChain Messages\n */\nexport {\n  BaseMessage,\n  AIMessage,\n  SystemMessage,\n  HumanMessage,\n  ToolMessage,\n} from \"@langchain/core/messages\";\n\n/**\n * Universal Chat Model\n */\nexport { initChatModel } from \"./chat_models/universal.js\";\n\n/**\n * LangChain Tools\n */\nexport { tool, DynamicStructuredTool } from \"@langchain/core/tools\";\n\n/**\n * LangChain Agents\n */\nexport {\n  createReactAgent,\n  toolStrategy,\n  providerStrategy,\n  ToolNode,\n  type AgentState,\n  type HumanInterrupt,\n  type HumanInterruptConfig,\n  type ActionRequest,\n  type HumanResponse,\n} from \"./agents/index.js\";\n\n/**\n * LangChain Memory\n * Check in what we want to export here\n */\nexport { MemorySaver, InMemoryStore } from \"@langchain/langgraph\";\n\n/**\n * LangChain Context\n */\nexport {\n  setContextVariable,\n  getContextVariable,\n} from \"@langchain/core/context\";\n\n/**\n * LangChain Documents\n */\nexport { Document } from \"@langchain/core/documents\";\n"],"mappings":""}
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * LangChain Messages\n */\nexport {\n  BaseMessage,\n  BaseMessageChunk,\n  AIMessage,\n  AIMessageChunk,\n  SystemMessage,\n  SystemMessageChunk,\n  HumanMessage,\n  HumanMessageChunk,\n  ToolMessage,\n  ToolMessageChunk,\n  type ContentBlock,\n  filterMessages,\n  trimMessages,\n} from \"@langchain/core/messages\";\n\n/**\n * Universal Chat Model\n */\nexport { initChatModel } from \"./chat_models/universal.js\";\n\n/**\n * LangChain Tools\n */\nexport { tool, DynamicStructuredTool } from \"@langchain/core/tools\";\n\n/**\n * LangChain Agents\n */\nexport {\n  createReactAgent,\n  toolStrategy,\n  providerStrategy,\n  ToolNode,\n  type AgentState,\n  type AgentRuntime,\n  type HumanInterrupt,\n  type HumanInterruptConfig,\n  type ActionRequest,\n  type HumanResponse,\n} from \"./agents/index.js\";\n\n/**\n * LangChain Memory\n * Check in what we want to export here\n */\nexport { MemorySaver, InMemoryStore } from \"@langchain/langgraph\";\n\n/**\n * LangChain Context\n */\nexport {\n  setContextVariable,\n  getContextVariable,\n} from \"@langchain/core/context\";\n\n/**\n * LangChain Documents\n */\nexport { Document } from \"@langchain/core/documents\";\n"],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langchain",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.3",
   "description": "Typescript bindings for langchain",
   "author": "LangChain",
   "license": "MIT",
@@ -47,7 +47,7 @@
     "typescript": "~5.8.3",
     "vitest": "^3.2.4",
     "@langchain/anthropic": "1.0.0-alpha.1",
-    "@langchain/core": "1.0.0-alpha.1",
+    "@langchain/core": "1.0.0-alpha.2",
     "@langchain/cohere": "0.3.4"
   },
   "peerDependencies": {