langchain 1.2.1 → 1.2.3-dev-1766726832377

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":["InteropZodObject","InteropZodType","START","END","StateGraph","LanguageModelLike","BaseMessage","SystemMessage","BaseCheckpointSaver","BaseStore","Messages","ClientTool","ServerTool","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","JsonSchemaFormat","ResponseFormatUndefined","AgentMiddleware","AnyAnnotationRoot","InferSchemaInput","JumpToTarget","N","Interrupt","TValue","BuiltInState","UserInput","TStateSchema","ToolCall","Record","ToolResult","JumpTo","ExecutedToolCall","CreateAgentParams","StructuredResponseType","StateSchema","ContextSchema","ResponseFormatType","AbortSignal","ExtractZodArrayTypes","T","Rest","A","WithStateGraphNodes","K","Graph","SD","S","U","I","O","C"],"sources":["../../src/agents/types.d.ts"],"sourcesContent":["import type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport type { START, END, StateGraph } from \"@langchain/langgraph\";\nimport type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { BaseMessage, SystemMessage } from \"@langchain/core/messages\";\nimport type { BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport type { Messages } from \"@langchain/langgraph/\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, JsonSchemaFormat, ResponseFormatUndefined } from \"./responses.js\";\nimport type { AgentMiddleware, AnyAnnotationRoot, InferSchemaInput } from \"./middleware/types.js\";\nimport type { JumpToTarget } from \"./constants.js\";\nexport type N = typeof START | \"model_request\" | \"tools\";\n/**\n * Represents information about an interrupt.\n */\nexport interface Interrupt<TValue = unknown> {\n    /**\n     * The ID of the interrupt.\n     */\n    id: string;\n    /**\n     * The requests for human input.\n     */\n    value: TValue;\n}\nexport interface BuiltInState {\n    messages: BaseMessage[];\n    __interrupt__?: Interrupt[];\n    /**\n     * Optional property to control routing after afterModel middleware execution.\n     * When set by middleware, the agent will jump to the specified node instead of\n     * following normal routing logic. The property is automatically cleared after use.\n     *\n     * - \"model_request\": Jump back to the model for another LLM call\n     * - \"tools\": Jump to tool execution (requires tools to be available)\n     */\n    jumpTo?: JumpToTarget;\n}\n/**\n * Base input type for `.invoke` and `.stream` methods.\n */\nexport type UserInput<TStateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined> = InferSchemaInput<TStateSchema> & {\n    messages: Messages;\n};\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ToolCall {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, any>;\n    /**\n     * The result of the tool call.\n     */\n    result?: unknown;\n    /**\n     * An optional error message if the tool call failed.\n     */\n    error?: string;\n}\n/**\n * Information about a tool result from a tool execution.\n */\nexport interface ToolResult {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The result of the tool call.\n     */\n    result: any;\n    /**\n     * An optional error message if the tool call failed.\n     */\n    error?: string;\n}\n/**\n * jump targets (internal)\n */\nexport type JumpTo = \"model_request\" | \"tools\" | typeof END;\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ExecutedToolCall {\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, unknown>;\n    /**\n     * The ID of the tool call.\n     */\n    tool_id: string;\n    /**\n     * The result of the tool call (if available).\n     */\n    result?: unknown;\n}\nexport type CreateAgentParams<StructuredResponseType extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\n    /**\n     * Defines a model to use for the agent. You can either pass in an instance of a LangChain chat model\n     * or a string. If a string is provided the agent initializes a ChatModel based on the provided model name and provider.\n     * It supports various model providers and allows for runtime configuration of model parameters.\n     *\n     * @uses {@link initChatModel}\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-7-sonnet-latest\",\n     *   // ...\n     * });\n     * ```\n     *\n     * @example\n     * ```ts\n     * import { ChatOpenAI } from \"@langchain/openai\";\n     * const agent = createAgent({\n     *   model: new ChatOpenAI({ model: \"gpt-4o\" }),\n     *   // ...\n     * });\n     * ```\n     */\n    model: string | LanguageModelLike;\n    /**\n     * A list of tools or a ToolNode.\n     *\n     * @example\n     * ```ts\n     * import { tool } from \"langchain\";\n     *\n     * const weatherTool = tool(() => \"Sunny!\", {\n     *   name: \"get_weather\",\n     *   description: \"Get the weather for a location\",\n     *   schema: z.object({\n     *     location: z.string().describe(\"The location to get weather for\"),\n     *   }),\n     * });\n     *\n     * const agent = createAgent({\n     *   tools: [weatherTool],\n     *   // ...\n     * });\n     * ```\n     */\n    tools?: (ServerTool | ClientTool)[];\n    /**\n     * An optional system message for the model.\n     *\n     * **Use a `string`** for simple, static system prompts. This is the most common use case\n     * and works well with template literals for dynamic content. When a string is provided,\n     * it's converted to a single text block internally.\n     *\n     * **Use a `SystemMessage`** when you need advanced features that require structured content:\n     * - **Anthropic cache control**: Use `SystemMessage` with array content to enable per-block\n     *   cache control settings (e.g., `cache_control: { type: \"ephemeral\" }`). This allows you\n     *   to have different cache settings for different parts of your system prompt.\n     * - **Multiple content blocks**: When you need multiple text blocks with different metadata\n     *   or formatting requirements.\n     * - **Integration with existing code**: When working with code that already produces\n     *   `SystemMessage` instances.\n     *\n     * @example Using a string (recommended for most cases)\n     * ```ts\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: \"You are a helpful assistant.\",\n     *   // ...\n     * });\n     * ```\n     *\n     * @example Using a string with template literals\n     * ```ts\n     * const userRole = \"premium\";\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: `You are a helpful assistant for ${userRole} users.`,\n     *   // ...\n     * });\n     * ```\n     *\n     * @example Using SystemMessage with cache control (Anthropic)\n     * ```ts\n     * import { SystemMessage } from \"@langchain/core/messages\";\n     *\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: new SystemMessage({\n     *     content: [\n     *       {\n     *         type: \"text\",\n     *         text: \"You are a helpful assistant.\",\n     *       },\n     *       {\n     *         type: \"text\",\n     *         text: \"Today's date is 2024-06-01.\",\n     *         cache_control: { type: \"ephemeral\" },\n     *       },\n     *     ],\n     *   }),\n     *   // ...\n     * });\n     * ```\n     *\n     * @example Using SystemMessage (simple)\n     * ```ts\n     * import { SystemMessage } from \"@langchain/core/messages\";\n     *\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: new SystemMessage(\"You are a helpful assistant.\"),\n     *   // ...\n     * });\n     * ```\n     */\n    systemPrompt?: string | SystemMessage;\n    /**\n     * An optional schema for the agent state. It allows you to define custom state properties that persist\n     * across agent invocations and can be accessed in hooks, middleware, and throughout the agent's execution.\n     * The state is persisted when using a checkpointer and can be updated by middleware or during execution.\n     *\n     * As opposed to the context (defined in `contextSchema`), the state is persisted between agent invocations\n     * when using a checkpointer, making it suitable for maintaining conversation history, user preferences,\n     * or any other data that should persist across multiple interactions.\n     *\n     * @example\n     * ```ts\n     * import { z } from \"zod\";\n     * import { createAgent } from \"@langchain/langgraph\";\n     *\n     * const agent = createAgent({\n     *   model: \"openai:gpt-4o\",\n     *   tools: [getWeather],\n     *   stateSchema: z.object({\n     *     userPreferences: z.object({\n     *       temperatureUnit: z.enum([\"celsius\", \"fahrenheit\"]).default(\"celsius\"),\n     *       location: z.string().optional(),\n     *     }).optional(),\n     *     conversationCount: z.number().default(0),\n     *   }),\n     *   prompt: (state, config) => {\n     *     const unit = state.userPreferences?.temperatureUnit || \"celsius\";\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. Use ${unit} for temperature.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new HumanMessage(\"What's the weather like?\"),\n     *   ],\n     *   userPreferences: {\n     *     temperatureUnit: \"fahrenheit\",\n     *     location: \"New York\",\n     *   },\n     *   conversationCount: 1,\n     * });\n     * ```\n     */\n    stateSchema?: StateSchema;\n    /**\n     * An optional schema for the context. It allows to pass in a typed context object into the agent\n     * invocation and allows to access it in hooks such as `prompt` and middleware.\n     * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between\n     * agent invocations.\n     *\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [getWeather],\n     *   contextSchema: z.object({\n     *     capital: z.string(),\n     *   }),\n     *   prompt: (state, config) => {\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. The capital of France is ${config.context.capital}.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new SystemMessage(\"You are a helpful assistant.\"),\n     *     new HumanMessage(\"What is the capital of France?\"),\n     *   ],\n     * }, {\n     *   context: {\n     *     capital: \"Paris\",\n     *   },\n     * });\n     * ```\n     */\n    contextSchema?: ContextSchema;\n    /**\n     * An optional checkpoint saver to persist the agent's state.\n     * @see {@link https://docs.langchain.com/oss/javascript/langgraph/persistence | Checkpointing}\n     */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /**\n     * An optional store to persist the agent's state.\n     * @see {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Long-term memory}\n     */\n    store?: BaseStore;\n    /**\n     * An optional schema for the final agent output.\n     *\n     * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.\n     * If not provided, `structuredResponse` will not be present in the output state.\n     *\n     * Can be passed in as:\n     *   - Zod schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: z.object({\n     *         capital: z.string(),\n     *       }),\n     *       // ...\n     *     });\n     *     ```\n     *   - JSON schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: {\n     *         type: \"json_schema\",\n     *         schema: {\n     *           type: \"object\",\n     *           properties: {\n     *             capital: { type: \"string\" },\n     *           },\n     *           required: [\"capital\"],\n     *         },\n     *       },\n     *       // ...\n     *     });\n     *     ```\n     *   - Create React Agent ResponseFormat\n     *     ```ts\n     *     import { providerStrategy, toolStrategy } from \"langchain\";\n     *     const agent = createAgent({\n     *       responseFormat: providerStrategy(\n     *         z.object({\n     *           capital: z.string(),\n     *         })\n     *       ),\n     *       // or\n     *       responseFormat: [\n     *         toolStrategy({ ... }),\n     *         toolStrategy({ ... }),\n     *       ]\n     *       // ...\n     *     });\n     *     ```\n     *\n     * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.\n     * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).\n     */\n    responseFormat?: ResponseFormatType;\n    /**\n     * Middleware instances to run during agent execution.\n     * Each middleware can define its own state schema and hook into the agent lifecycle.\n     *\n     * @see {@link https://docs.langchain.com/oss/javascript/langchain/middleware | Middleware}\n     */\n    middleware?: readonly AgentMiddleware<any, any, any>[];\n    /**\n     * An optional name for the agent.\n     */\n    name?: string;\n    /**\n     * An optional description for the agent.\n     * This can be used to describe the agent to the underlying supervisor LLM.\n     */\n    description?: string;\n    /**\n     * Use to specify how to expose the agent name to the underlying supervisor LLM.\n     *   - `undefined`: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.\n     *   - `\"inline\"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.\n     *       Example: `\"How can I help you\"` -> `\"<name>agent_name</name><content>How can I help you?</content>\"`\n     */\n    includeAgentName?: \"inline\" | undefined;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n    /**\n     * Determines the version of the graph to create.\n     *\n     * Can be one of\n     * - `\"v1\"`: The tool node processes a single message. All tool calls in the message are\n     *           executed in parallel within the tool node.\n     * - `\"v2\"`: The tool node processes a single tool call. Tool calls are distributed across\n     *           multiple instances of the tool node using the Send API.\n     *\n     * @default `\"v2\"`\n     */\n    version?: \"v1\" | \"v2\";\n};\n/**\n * Type helper to extract union type from an array of Zod schemas\n */\nexport type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;\nexport type WithStateGraphNodes<K extends string, Graph> = Graph extends StateGraph<infer SD, infer S, infer U, infer N, infer I, infer O, infer C> ? StateGraph<SD, S, U, N | K, I, O, C> : never;\n//# sourceMappingURL=types.d.ts.map"],"mappings":";;;;;;;;;;;;KAUYuB,CAAAA,UAAWrB;;AAAvB;AAIA;AAUiBwB,UAVAF,SAUY,CAAA,SAAA,OAAA,CAAA,CAAA;EACflB;;;EAUW,EAAA,EAAA,MAAA;EAKbqB;;;EAAgHC,KAAAA,EAlBjHH,MAkBiHG;;AAC9GlB,UAjBGgB,YAAAA,CAiBHhB;EAAQ,QAAA,EAhBRJ,WAgBQ,EAAA;EAKLuB,aAAQ,CAAA,EApBLL,SAoBK,EAYfM;EAaOC;AAiBjB;AAIA;AAkBA;;;;;EAAgNX,MAAAA,CAAAA,EA3EnME,YA2EmMF;;;;;AAAwHnB,KAtE5T0B,SAsE4T1B,CAAAA,qBAtE7RmB,iBAsE6RnB,GAtEzQD,gBAsEyQC,GAAAA,SAAAA,GAAAA,SAAAA,CAAAA,GAtE7NoB,gBAsE6NpB,CAtE5M2B,YAsE4M3B,CAAAA,GAAAA;EAA4BgB,QAAAA,EArEtVP,QAqEsVO;CAAmBA;;;;AAA+FkB,UAhErcN,UAAAA,CAgEqcM;EAAbrB;;;EAAkFI,EAAAA,EAAAA,MAAAA;EAwBvgBb;;;EA4FQE,IAAAA,EAAAA,MAAAA;EA6CV6B;;;EA4CN3B,IAAAA,EAjQFqB,MAiQErB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAsDS6B;;;EA2BG,MAAA,CAAA,EAAA,OAAA;EAiBZE;;;EAAqFvC,KAAAA,CAAAA,EAAAA,MAAAA;;;;;AAA4FuC,UAtV5KT,UAAAA,CAsV4KS;EAA6BG;AAAC;AAC3N;EAA2DG,EAAAA,EAAAA,MAAAA;EAAc1C;;;EAA+F6C,MAAAA,EAAAA,GAAAA;EAAG1B;;;EAAU4B,KAAAA,CAAAA,EAAAA,MAAAA;;;AAArB;;KAtUpJnB,MAAAA,sCAA4C7B;;;;UAIvC8B,gBAAAA;;;;;;;;QAQPH;;;;;;;;;;KAUEI,iDAAiDJ,sBAAsBA,yCAAyCV,oBAAoBpB,gEAAgEoB,oBAAoBpB,mBAAmBoB,wCAAwCnB,eAAekC,0BAA0BlC,4BAA4BgB,mBAAmBA,qBAAqBJ,iBAAiBE,kBAAkBoB,0BAA0BrB,aAAaqB,0BAA0BnB,iBAAiBmB,0BAA0BjB;;;;;;;;;;;;;;;;;;;;;;;;kBAwBvgBb;;;;;;;;;;;;;;;;;;;;;;WAsBPO,aAAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsEEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA6CV6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkCEC;;;;;iBAKD7B;;;;;UAKPC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsDS6B;;;;;;;wBAOKnB;;;;;;;;;;;;;;;;;;;;WAoBboB;;;;;;;;;;;;;;;;;KAiBDC,wCAAwCvC,yBAAyBwC,oBAAoBxC,0CAA0CyC,sBAAsBzC,wBAAwB0C,IAAIH,qBAAqBE,QAAQC;KAC9MC,+CAA+CE,cAAc1C,6EAA6EA,WAAW2C,IAAIC,GAAGC,GAAG1B,IAAIsB,GAAGK,GAAGC,GAAGC"}
+{"version":3,"file":"types.d.cts","names":["InteropZodObject","InteropZodType","START","END","StateGraph","LanguageModelLike","BaseMessage","SystemMessage","BaseCheckpointSaver","BaseStore","Messages","ClientTool","ServerTool","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","JsonSchemaFormat","ResponseFormatUndefined","AgentMiddleware","AnyAnnotationRoot","InferSchemaInput","JumpToTarget","N","Interrupt","TValue","BuiltInState","UserInput","TStateSchema","ToolCall","Record","ToolResult","JumpTo","ExecutedToolCall","CreateAgentParams","StructuredResponseType","StateSchema","ContextSchema","ResponseFormatType","AbortSignal","ExtractZodArrayTypes","T","Rest","A","WithStateGraphNodes","K","Graph","SD","S","U","I","O","C"],"sources":["../../src/agents/types.d.ts"],"sourcesContent":["import type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport type { START, END, StateGraph } from \"@langchain/langgraph\";\nimport type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { BaseMessage, SystemMessage } from \"@langchain/core/messages\";\nimport type { BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport type { Messages } from \"@langchain/langgraph/\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, JsonSchemaFormat, ResponseFormatUndefined } from \"./responses.js\";\nimport type { AgentMiddleware, AnyAnnotationRoot, InferSchemaInput } from \"./middleware/types.js\";\nimport type { JumpToTarget } from \"./constants.js\";\nexport type N = typeof START | \"model_request\" | \"tools\";\n/**\n * Represents information about an interrupt.\n */\nexport interface Interrupt<TValue = unknown> {\n    /**\n     * The ID of the interrupt.\n     */\n    id: string;\n    /**\n     * The requests for human input.\n     */\n    value: TValue;\n}\nexport interface BuiltInState {\n    messages: BaseMessage[];\n    __interrupt__?: Interrupt[];\n    /**\n     * Optional property to control routing after afterModel middleware execution.\n     * When set by middleware, the agent will jump to the specified node instead of\n     * following normal routing logic. The property is automatically cleared after use.\n     *\n     * - \"model_request\": Jump back to the model for another LLM call\n     * - \"tools\": Jump to tool execution (requires tools to be available)\n     */\n    jumpTo?: JumpToTarget;\n}\n/**\n * Base input type for `.invoke` and `.stream` methods.\n */\nexport type UserInput<TStateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined> = InferSchemaInput<TStateSchema> & {\n    messages: Messages;\n};\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ToolCall {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, any>;\n    /**\n     * The result of the tool call.\n     */\n    result?: unknown;\n    /**\n     * An optional error message if the tool call failed.\n     */\n    error?: string;\n}\n/**\n * Information about a tool result from a tool execution.\n */\nexport interface ToolResult {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The result of the tool call.\n     */\n    result: any;\n    /**\n     * An optional error message if the tool call failed.\n     */\n    error?: string;\n}\n/**\n * jump targets (internal)\n */\nexport type JumpTo = \"model_request\" | \"tools\" | typeof END;\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ExecutedToolCall {\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, unknown>;\n    /**\n     * The ID of the tool call.\n     */\n    tool_id: string;\n    /**\n     * The result of the tool call (if available).\n     */\n    result?: unknown;\n}\nexport type CreateAgentParams<StructuredResponseType extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\n    /**\n     * Defines a model to use for the agent. You can either pass in an instance of a LangChain chat model\n     * or a string. If a string is provided the agent initializes a ChatModel based on the provided model name and provider.\n     * It supports various model providers and allows for runtime configuration of model parameters.\n     *\n     * @uses {@link initChatModel}\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-7-sonnet-latest\",\n     *   // ...\n     * });\n     * ```\n     *\n     * @example\n     * ```ts\n     * import { ChatOpenAI } from \"@langchain/openai\";\n     * const agent = createAgent({\n     *   model: new ChatOpenAI({ model: \"gpt-4o\" }),\n     *   // ...\n     * });\n     * ```\n     */\n    model: string | LanguageModelLike;\n    /**\n     * A list of tools or a ToolNode.\n     *\n     * @example\n     * ```ts\n     * import { tool } from \"langchain\";\n     *\n     * const weatherTool = tool(() => \"Sunny!\", {\n     *   name: \"get_weather\",\n     *   description: \"Get the weather for a location\",\n     *   schema: z.object({\n     *     location: z.string().describe(\"The location to get weather for\"),\n     *   }),\n     * });\n     *\n     * const agent = createAgent({\n     *   tools: [weatherTool],\n     *   // ...\n     * });\n     * ```\n     */\n    tools?: (ServerTool | ClientTool)[];\n    /**\n     * An optional system message for the model.\n     *\n     * **Use a `string`** for simple, static system prompts. This is the most common use case\n     * and works well with template literals for dynamic content. When a string is provided,\n     * it's converted to a single text block internally.\n     *\n     * **Use a `SystemMessage`** when you need advanced features that require structured content:\n     * - **Anthropic cache control**: Use `SystemMessage` with array content to enable per-block\n     *   cache control settings (e.g., `cache_control: { type: \"ephemeral\" }`). This allows you\n     *   to have different cache settings for different parts of your system prompt.\n     * - **Multiple content blocks**: When you need multiple text blocks with different metadata\n     *   or formatting requirements.\n     * - **Integration with existing code**: When working with code that already produces\n     *   `SystemMessage` instances.\n     *\n     * @example Using a string (recommended for most cases)\n     * ```ts\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: \"You are a helpful assistant.\",\n     *   // ...\n     * });\n     * ```\n     *\n     * @example Using a string with template literals\n     * ```ts\n     * const userRole = \"premium\";\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: `You are a helpful assistant for ${userRole} users.`,\n     *   // ...\n     * });\n     * ```\n     *\n     * @example Using SystemMessage with cache control (Anthropic)\n     * ```ts\n     * import { SystemMessage } from \"@langchain/core/messages\";\n     *\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: new SystemMessage({\n     *     content: [\n     *       {\n     *         type: \"text\",\n     *         text: \"You are a helpful assistant.\",\n     *       },\n     *       {\n     *         type: \"text\",\n     *         text: \"Today's date is 2024-06-01.\",\n     *         cache_control: { type: \"ephemeral\" },\n     *       },\n     *     ],\n     *   }),\n     *   // ...\n     * });\n     * ```\n     *\n     * @example Using SystemMessage (simple)\n     * ```ts\n     * import { SystemMessage } from \"@langchain/core/messages\";\n     *\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: new SystemMessage(\"You are a helpful assistant.\"),\n     *   // ...\n     * });\n     * ```\n     */\n    systemPrompt?: string | SystemMessage;\n    /**\n     * An optional schema for the agent state. It allows you to define custom state properties that persist\n     * across agent invocations and can be accessed in hooks, middleware, and throughout the agent's execution.\n     * The state is persisted when using a checkpointer and can be updated by middleware or during execution.\n     *\n     * As opposed to the context (defined in `contextSchema`), the state is persisted between agent invocations\n     * when using a checkpointer, making it suitable for maintaining conversation history, user preferences,\n     * or any other data that should persist across multiple interactions.\n     *\n     * @example\n     * ```ts\n     * import { z } from \"zod\";\n     * import { createAgent } from \"@langchain/langgraph\";\n     *\n     * const agent = createAgent({\n     *   model: \"openai:gpt-4o\",\n     *   tools: [getWeather],\n     *   stateSchema: z.object({\n     *     userPreferences: z.object({\n     *       temperatureUnit: z.enum([\"celsius\", \"fahrenheit\"]).default(\"celsius\"),\n     *       location: z.string().optional(),\n     *     }).optional(),\n     *     conversationCount: z.number().default(0),\n     *   }),\n     *   prompt: (state, config) => {\n     *     const unit = state.userPreferences?.temperatureUnit || \"celsius\";\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. Use ${unit} for temperature.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new HumanMessage(\"What's the weather like?\"),\n     *   ],\n     *   userPreferences: {\n     *     temperatureUnit: \"fahrenheit\",\n     *     location: \"New York\",\n     *   },\n     *   conversationCount: 1,\n     * });\n     * ```\n     */\n    stateSchema?: StateSchema;\n    /**\n     * An optional schema for the context. It allows to pass in a typed context object into the agent\n     * invocation and allows to access it in hooks such as `prompt` and middleware.\n     * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between\n     * agent invocations.\n     *\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [getWeather],\n     *   contextSchema: z.object({\n     *     capital: z.string(),\n     *   }),\n     *   prompt: (state, config) => {\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. The capital of France is ${config.context.capital}.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new SystemMessage(\"You are a helpful assistant.\"),\n     *     new HumanMessage(\"What is the capital of France?\"),\n     *   ],\n     * }, {\n     *   context: {\n     *     capital: \"Paris\",\n     *   },\n     * });\n     * ```\n     */\n    contextSchema?: ContextSchema;\n    /**\n     * An optional checkpoint saver to persist the agent's state.\n     * @see {@link https://docs.langchain.com/oss/javascript/langgraph/persistence | Checkpointing}\n     */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /**\n     * An optional store to persist the agent's state.\n     * @see {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Long-term memory}\n     */\n    store?: BaseStore;\n    /**\n     * An optional schema for the final agent output.\n     *\n     * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.\n     * If not provided, `structuredResponse` will not be present in the output state.\n     *\n     * Can be passed in as:\n     *   - Zod schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: z.object({\n     *         capital: z.string(),\n     *       }),\n     *       // ...\n     *     });\n     *     ```\n     *   - JSON schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: {\n     *         type: \"json_schema\",\n     *         schema: {\n     *           type: \"object\",\n     *           properties: {\n     *             capital: { type: \"string\" },\n     *           },\n     *           required: [\"capital\"],\n     *         },\n     *       },\n     *       // ...\n     *     });\n     *     ```\n     *   - Create React Agent ResponseFormat\n     *     ```ts\n     *     import { providerStrategy, toolStrategy } from \"langchain\";\n     *     const agent = createAgent({\n     *       responseFormat: providerStrategy(\n     *         z.object({\n     *           capital: z.string(),\n     *         })\n     *       ),\n     *       // or\n     *       responseFormat: [\n     *         toolStrategy({ ... }),\n     *         toolStrategy({ ... }),\n     *       ]\n     *       // ...\n     *     });\n     *     ```\n     *\n     * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.\n     * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).\n     */\n    responseFormat?: ResponseFormatType;\n    /**\n     * Middleware instances to run during agent execution.\n     * Each middleware can define its own state schema and hook into the agent lifecycle.\n     *\n     * @see {@link https://docs.langchain.com/oss/javascript/langchain/middleware | Middleware}\n     */\n    middleware?: readonly AgentMiddleware<any, any, any>[];\n    /**\n     * An optional name for the agent.\n     */\n    name?: string;\n    /**\n     * An optional description for the agent.\n     * This can be used to describe the agent to the underlying supervisor LLM.\n     */\n    description?: string;\n    /**\n     * Use to specify how to expose the agent name to the underlying supervisor LLM.\n     *   - `undefined`: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.\n     *   - `\"inline\"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.\n     *       Example: `\"How can I help you\"` -> `\"<name>agent_name</name><content>How can I help you?</content>\"`\n     */\n    includeAgentName?: \"inline\" | undefined;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n    /**\n     * Determines the version of the graph to create.\n     *\n     * Can be one of\n     * - `\"v1\"`: The tool node processes a single message. All tool calls in the message are\n     *           executed in parallel within the tool node.\n     * - `\"v2\"`: The tool node processes a single tool call. Tool calls are distributed across\n     *           multiple instances of the tool node using the Send API.\n     *\n     * @default `\"v2\"`\n     */\n    version?: \"v1\" | \"v2\";\n};\n/**\n * Type helper to extract union type from an array of Zod schemas\n */\nexport type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;\nexport type WithStateGraphNodes<K extends string, Graph> = Graph extends StateGraph<infer SD, infer S, infer U, infer N, infer I, infer O, infer C> ? StateGraph<SD, S, U, N | K, I, O, C> : never;\n//# sourceMappingURL=types.d.ts.map"],"mappings":";;;;;;;;;;;;KAUYuB,CAAAA,UAAWrB;;AAAvB;AAIA;AAUiBwB,UAVAF,SAUY,CAAA,SAAA,OAAA,CAAA,CAAA;EACflB;;;EAUW,EAAA,EAAA,MAAA;EAKbqB;;;EAAgHC,KAAAA,EAlBjHH,MAkBiHG;;AAC9GlB,UAjBGgB,YAAAA,CAiBHhB;EAAQ,QAAA,EAhBRJ,WAgBQ,EAAA;EAKLuB,aAAQ,CAAA,EApBLL,SAgCVM,EAAAA;EAaOC;AAiBjB;AAIA;AAkBA;;;;;EAAgNX,MAAAA,CAAAA,EA3EnME,YA2EmMF;;;;;AAAwHnB,KAtE5T0B,SAsE4T1B,CAAAA,qBAtE7RmB,iBAsE6RnB,GAtEzQD,gBAsEyQC,GAAAA,SAAAA,GAAAA,SAAAA,CAAAA,GAtE7NoB,gBAsE6NpB,CAtE5M2B,YAsE4M3B,CAAAA,GAAAA;EAA4BgB,QAAAA,EArEtVP,QAqEsVO;CAAmBA;;;;AAA+FkB,UAhErcN,UAAAA,CAgEqcM;EAAbrB;;;EAAkFI,EAAAA,EAAAA,MAAAA;EAwBvgBb;;;EA4FQE,IAAAA,EAAAA,MAAAA;EA6CV6B;;;EA4CN3B,IAAAA,EAjQFqB,MAiQErB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAsDS6B;;;EA2BG,MAAA,CAAA,EAAA,OAAA;EAiBZE;;;EAAqFvC,KAAAA,CAAAA,EAAAA,MAAAA;;;;;AAA4FuC,UAtV5KT,UAAAA,CAsV4KS;EAA6BG;AAAC;AAC3N;EAA2DG,EAAAA,EAAAA,MAAAA;EAAc1C;;;EAA+F6C,MAAAA,EAAAA,GAAAA;EAAG1B;;;EAAU4B,KAAAA,CAAAA,EAAAA,MAAAA;;;AAArB;;KAtUpJnB,MAAAA,sCAA4C7B;;;;UAIvC8B,gBAAAA;;;;;;;;QAQPH;;;;;;;;;;KAUEI,iDAAiDJ,sBAAsBA,yCAAyCV,oBAAoBpB,gEAAgEoB,oBAAoBpB,mBAAmBoB,wCAAwCnB,eAAekC,0BAA0BlC,4BAA4BgB,mBAAmBA,qBAAqBJ,iBAAiBE,kBAAkBoB,0BAA0BrB,aAAaqB,0BAA0BnB,iBAAiBmB,0BAA0BjB;;;;;;;;;;;;;;;;;;;;;;;;kBAwBvgBb;;;;;;;;;;;;;;;;;;;;;;WAsBPO,aAAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsEEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA6CV6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkCEC;;;;;iBAKD7B;;;;;UAKPC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsDS6B;;;;;;;wBAOKnB;;;;;;;;;;;;;;;;;;;;WAoBboB;;;;;;;;;;;;;;;;;KAiBDC,wCAAwCvC,yBAAyBwC,oBAAoBxC,0CAA0CyC,sBAAsBzC,wBAAwB0C,IAAIH,qBAAqBE,QAAQC;KAC9MC,+CAA+CE,cAAc1C,6EAA6EA,WAAW2C,IAAIC,GAAGC,GAAG1B,IAAIsB,GAAGK,GAAGC,GAAGC"}

package/dist/index.cjs

@@ -1,5 +1,6 @@
 const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
 const require_chat_models_universal = require('./chat_models/universal.cjs');
+const require_browser = require('./tools/browser.cjs');
 const require_errors = require('./agents/errors.cjs');
 const require_responses = require('./agents/responses.cjs');
 const require_utils = require('./agents/middleware/utils.cjs');
@@ -26,6 +27,7 @@ const require_promptCaching = require('./agents/middleware/provider/anthropic/pr
 require('./agents/middleware/index.cjs');
 const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
 const __langchain_core_tools = require_rolldown_runtime.__toESM(require("@langchain/core/tools"));
+const __langchain_core_utils_context = require_rolldown_runtime.__toESM(require("@langchain/core/utils/context"));
 const __langchain_core_stores = require_rolldown_runtime.__toESM(require("@langchain/core/stores"));
 const __langchain_core_documents = require_rolldown_runtime.__toESM(require("@langchain/core/documents"));
 
@@ -62,6 +64,8 @@ require_rolldown_runtime.__export(src_exports, {
 	ToolStrategy: () => require_responses.ToolStrategy,
 	anthropicPromptCachingMiddleware: () => require_promptCaching.anthropicPromptCachingMiddleware,
 	applyStrategy: () => require_pii.applyStrategy,
+	browserTool: () => require_browser.browserTool,
+	context: () => __langchain_core_utils_context.context,
 	contextEditingMiddleware: () => require_contextEditing.contextEditingMiddleware,
 	countTokensApproximately: () => require_utils.countTokensApproximately,
 	createAgent: () => require_index.createAgent,
@@ -205,6 +209,13 @@ Object.defineProperty(exports, 'ToolMessageChunk', {
 exports.ToolStrategy = require_responses.ToolStrategy;
 exports.anthropicPromptCachingMiddleware = require_promptCaching.anthropicPromptCachingMiddleware;
 exports.applyStrategy = require_pii.applyStrategy;
+exports.browserTool = require_browser.browserTool;
+Object.defineProperty(exports, 'context', {
+  enumerable: true,
+  get: function () {
+    return __langchain_core_utils_context.context;
+  }
+});
 exports.contextEditingMiddleware = require_contextEditing.contextEditingMiddleware;
 exports.countTokensApproximately = require_utils.countTokensApproximately;
 exports.createAgent = require_index.createAgent;

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  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 {\n  tool,\n  Tool,\n  type ToolRuntime,\n  DynamicTool,\n  StructuredTool,\n  DynamicStructuredTool,\n} from \"@langchain/core/tools\";\n\n/**\n * LangChain Agents\n */\nexport * from \"./agents/index.js\";\n\n/**\n * `createAgent` pre-built middleware\n */\nexport * from \"./agents/middleware/index.js\";\n\n/**\n * LangChain Stores\n */\nexport { InMemoryStore } from \"@langchain/core/stores\";\n\n/**\n * LangChain Documents\n */\nexport { type DocumentInput, 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 {\n  tool,\n  Tool,\n  type ToolRuntime,\n  DynamicTool,\n  StructuredTool,\n  DynamicStructuredTool,\n} from \"@langchain/core/tools\";\n\n/**\n * Browser Tools\n */\nexport {\n  browserTool,\n  type BrowserTool,\n  type BrowserToolParams,\n} from \"./tools/browser.js\";\n\n/**\n * LangChain utilities\n */\nexport { context } from \"@langchain/core/utils/context\";\n\n/**\n * LangChain Agents\n */\nexport * from \"./agents/index.js\";\n\n/**\n * `createAgent` pre-built middleware\n */\nexport * from \"./agents/middleware/index.js\";\n\n/**\n * LangChain Stores\n */\nexport { InMemoryStore } from \"@langchain/core/stores\";\n\n/**\n * LangChain Documents\n */\nexport { type DocumentInput, Document } from \"@langchain/core/documents\";\n"],"mappings":""}

package/dist/index.d.cts

@@ -1,4 +1,5 @@
 import { initChatModel } from "./chat_models/universal.cjs";
+import { BrowserTool, BrowserToolParams, browserTool } from "./tools/browser.cjs";
 import { MultipleStructuredOutputsError, MultipleToolsBoundError, StructuredOutputParsingError, ToolInvocationError } from "./agents/errors.cjs";
 import { ProviderStrategy, ResponseFormat, ResponseFormatUndefined, ToolStrategy, providerStrategy, toolStrategy } from "./agents/responses.cjs";
 import { JumpToTarget } from "./agents/constants.cjs";
@@ -28,6 +29,7 @@ import { PromptCachingMiddlewareConfig, anthropicPromptCachingMiddleware } from
 import { countTokensApproximately } from "./agents/middleware/utils.cjs";
 import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ContentBlock, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, filterMessages, trimMessages } from "@langchain/core/messages";
 import { DynamicStructuredTool, DynamicTool, StructuredTool, Tool, ToolRuntime, tool } from "@langchain/core/tools";
+import { context } from "@langchain/core/utils/context";
 import { InMemoryStore } from "@langchain/core/stores";
 import { Document, DocumentInput } from "@langchain/core/documents";
-export { AIMessage, AIMessageChunk, Action, ActionRequest, AfterAgentHook, AfterModelHook, AgentMiddleware, AnyAnnotationRoot, ApproveDecision, BaseMessage, BaseMessageChunk, BeforeAgentHook, BeforeModelHook, BuiltInPIIType, BuiltInState, ClearToolUsesEdit, ClearToolUsesEditConfig, type ContentBlock, ContextEdit, ContextEditingMiddlewareConfig, CreateAgentParams, Decision, DecisionType, DescriptionFactory, Document, type DocumentInput, DynamicStructuredTool, DynamicSystemPromptMiddlewareConfig, DynamicTool, EditDecision, ExecutedToolCall, ExtractZodArrayTypes, FakeToolCallingModel, HITLRequest, HITLResponse, HumanInTheLoopMiddlewareConfig, HumanMessage, HumanMessageChunk, InMemoryStore, InferChannelType, InferContextInput, InferMergedInputState, InferMergedState, InferMiddlewareContext, InferMiddlewareContextInput, InferMiddlewareContextInputs, InferMiddlewareContexts, InferMiddlewareInputState, InferMiddlewareInputStates, InferMiddlewareState, InferMiddlewareStates, InferSchemaInput, Interrupt, InterruptOnConfig, JumpTo, JumpToTarget, LLMToolSelectorConfig, MIDDLEWARE_BRAND, MiddlewareResult, ModelCallLimitMiddlewareConfig, ModelRetryMiddlewareConfig, MultipleStructuredOutputsError, MultipleToolsBoundError, N, NormalizedSchemaInput, OpenAIModerationMiddlewareOptions, PIIDetectionError, PIIDetector, PIIMatch, PIIMiddlewareConfig, PIIRedactionMiddlewareConfig, PIIStrategy, PromptCachingMiddlewareConfig, ProviderStrategy, ReactAgent, RedactionRuleConfig, RejectDecision, ResolvedRedactionRule, ResponseFormat, ResponseFormatUndefined, ReviewConfig, Runtime, StructuredOutputParsingError, StructuredTool, SummarizationMiddlewareConfig, SystemMessage, SystemMessageChunk, TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT, ToAnnotationRoot, TodoListMiddlewareOptions, TokenCounter, Tool, ToolCall, ToolCallHandler, ToolCallLimitConfig, ToolCallLimitExceededError, ToolCallRequest, ToolEmulatorOptions, ToolInvocationError, ToolMessage, ToolMessageChunk, ToolResult, ToolRetryMiddlewareConfig, type ToolRuntime, ToolStrategy, UserInput, WithStateGraphNodes, WrapModelCallHandler, WrapModelCallHook, WrapToolCallHook, anthropicPromptCachingMiddleware, applyStrategy, contextEditingMiddleware, countTokensApproximately, createAgent, createMiddleware, detectCreditCard, detectEmail, detectIP, detectMacAddress, detectUrl, dynamicSystemPromptMiddleware, filterMessages, humanInTheLoopMiddleware, initChatModel, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, modelRetryMiddleware, openAIModerationMiddleware, piiMiddleware, piiRedactionMiddleware, providerStrategy, resolveRedactionRule, summarizationMiddleware, todoListMiddleware, tool, toolCallLimitMiddleware, toolEmulatorMiddleware, toolRetryMiddleware, toolStrategy, trimMessages };
+export { AIMessage, AIMessageChunk, Action, ActionRequest, AfterAgentHook, AfterModelHook, AgentMiddleware, AnyAnnotationRoot, ApproveDecision, BaseMessage, BaseMessageChunk, BeforeAgentHook, BeforeModelHook, type BrowserTool, type BrowserToolParams, BuiltInPIIType, BuiltInState, ClearToolUsesEdit, ClearToolUsesEditConfig, type ContentBlock, ContextEdit, ContextEditingMiddlewareConfig, CreateAgentParams, Decision, DecisionType, DescriptionFactory, Document, type DocumentInput, DynamicStructuredTool, DynamicSystemPromptMiddlewareConfig, DynamicTool, EditDecision, ExecutedToolCall, ExtractZodArrayTypes, FakeToolCallingModel, HITLRequest, HITLResponse, HumanInTheLoopMiddlewareConfig, HumanMessage, HumanMessageChunk, InMemoryStore, InferChannelType, InferContextInput, InferMergedInputState, InferMergedState, InferMiddlewareContext, InferMiddlewareContextInput, InferMiddlewareContextInputs, InferMiddlewareContexts, InferMiddlewareInputState, InferMiddlewareInputStates, InferMiddlewareState, InferMiddlewareStates, InferSchemaInput, Interrupt, InterruptOnConfig, JumpTo, JumpToTarget, LLMToolSelectorConfig, MIDDLEWARE_BRAND, MiddlewareResult, ModelCallLimitMiddlewareConfig, ModelRetryMiddlewareConfig, MultipleStructuredOutputsError, MultipleToolsBoundError, N, NormalizedSchemaInput, OpenAIModerationMiddlewareOptions, PIIDetectionError, PIIDetector, PIIMatch, PIIMiddlewareConfig, PIIRedactionMiddlewareConfig, PIIStrategy, PromptCachingMiddlewareConfig, ProviderStrategy, ReactAgent, RedactionRuleConfig, RejectDecision, ResolvedRedactionRule, ResponseFormat, ResponseFormatUndefined, ReviewConfig, Runtime, StructuredOutputParsingError, StructuredTool, SummarizationMiddlewareConfig, SystemMessage, SystemMessageChunk, TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT, ToAnnotationRoot, TodoListMiddlewareOptions, TokenCounter, Tool, ToolCall, ToolCallHandler, ToolCallLimitConfig, ToolCallLimitExceededError, ToolCallRequest, ToolEmulatorOptions, ToolInvocationError, ToolMessage, ToolMessageChunk, ToolResult, ToolRetryMiddlewareConfig, type ToolRuntime, ToolStrategy, UserInput, WithStateGraphNodes, WrapModelCallHandler, WrapModelCallHook, WrapToolCallHook, anthropicPromptCachingMiddleware, applyStrategy, browserTool, context, contextEditingMiddleware, countTokensApproximately, createAgent, createMiddleware, detectCreditCard, detectEmail, detectIP, detectMacAddress, detectUrl, dynamicSystemPromptMiddleware, filterMessages, humanInTheLoopMiddleware, initChatModel, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, modelRetryMiddleware, openAIModerationMiddleware, piiMiddleware, piiRedactionMiddleware, providerStrategy, resolveRedactionRule, summarizationMiddleware, todoListMiddleware, tool, toolCallLimitMiddleware, toolEmulatorMiddleware, toolRetryMiddleware, toolStrategy, trimMessages };

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { initChatModel } from "./chat_models/universal.js";
+import { BrowserTool, BrowserToolParams, browserTool } from "./tools/browser.js";
 import { MultipleStructuredOutputsError, MultipleToolsBoundError, StructuredOutputParsingError, ToolInvocationError } from "./agents/errors.js";
 import { ProviderStrategy, ResponseFormat, ResponseFormatUndefined, ToolStrategy, providerStrategy, toolStrategy } from "./agents/responses.js";
 import { JumpToTarget } from "./agents/constants.js";
@@ -29,6 +30,7 @@ import { countTokensApproximately } from "./agents/middleware/utils.js";
 import "./agents/middleware/index.js";
 import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ContentBlock, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, filterMessages, trimMessages } from "@langchain/core/messages";
 import { DynamicStructuredTool, DynamicTool, StructuredTool, Tool, ToolRuntime, tool } from "@langchain/core/tools";
+import { context } from "@langchain/core/utils/context";
 import { InMemoryStore } from "@langchain/core/stores";
 import { Document, DocumentInput } from "@langchain/core/documents";
-export { AIMessage, AIMessageChunk, Action, ActionRequest, AfterAgentHook, AfterModelHook, AgentMiddleware, AnyAnnotationRoot, ApproveDecision, BaseMessage, BaseMessageChunk, BeforeAgentHook, BeforeModelHook, BuiltInPIIType, BuiltInState, ClearToolUsesEdit, ClearToolUsesEditConfig, type ContentBlock, ContextEdit, ContextEditingMiddlewareConfig, CreateAgentParams, Decision, DecisionType, DescriptionFactory, Document, type DocumentInput, DynamicStructuredTool, DynamicSystemPromptMiddlewareConfig, DynamicTool, EditDecision, ExecutedToolCall, ExtractZodArrayTypes, FakeToolCallingModel, HITLRequest, HITLResponse, HumanInTheLoopMiddlewareConfig, HumanMessage, HumanMessageChunk, InMemoryStore, InferChannelType, InferContextInput, InferMergedInputState, InferMergedState, InferMiddlewareContext, InferMiddlewareContextInput, InferMiddlewareContextInputs, InferMiddlewareContexts, InferMiddlewareInputState, InferMiddlewareInputStates, InferMiddlewareState, InferMiddlewareStates, InferSchemaInput, Interrupt, InterruptOnConfig, JumpTo, JumpToTarget, LLMToolSelectorConfig, MIDDLEWARE_BRAND, MiddlewareResult, ModelCallLimitMiddlewareConfig, ModelRetryMiddlewareConfig, MultipleStructuredOutputsError, MultipleToolsBoundError, N, NormalizedSchemaInput, OpenAIModerationMiddlewareOptions, PIIDetectionError, PIIDetector, PIIMatch, PIIMiddlewareConfig, PIIRedactionMiddlewareConfig, PIIStrategy, PromptCachingMiddlewareConfig, ProviderStrategy, ReactAgent, RedactionRuleConfig, RejectDecision, ResolvedRedactionRule, ResponseFormat, ResponseFormatUndefined, ReviewConfig, Runtime, StructuredOutputParsingError, StructuredTool, SummarizationMiddlewareConfig, SystemMessage, SystemMessageChunk, TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT, ToAnnotationRoot, TodoListMiddlewareOptions, TokenCounter, Tool, ToolCall, ToolCallHandler, ToolCallLimitConfig, ToolCallLimitExceededError, ToolCallRequest, ToolEmulatorOptions, ToolInvocationError, ToolMessage, ToolMessageChunk, ToolResult, ToolRetryMiddlewareConfig, type ToolRuntime, ToolStrategy, UserInput, WithStateGraphNodes, WrapModelCallHandler, WrapModelCallHook, WrapToolCallHook, anthropicPromptCachingMiddleware, applyStrategy, contextEditingMiddleware, countTokensApproximately, createAgent, createMiddleware, detectCreditCard, detectEmail, detectIP, detectMacAddress, detectUrl, dynamicSystemPromptMiddleware, filterMessages, humanInTheLoopMiddleware, initChatModel, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, modelRetryMiddleware, openAIModerationMiddleware, piiMiddleware, piiRedactionMiddleware, providerStrategy, resolveRedactionRule, summarizationMiddleware, todoListMiddleware, tool, toolCallLimitMiddleware, toolEmulatorMiddleware, toolRetryMiddleware, toolStrategy, trimMessages };
+export { AIMessage, AIMessageChunk, Action, ActionRequest, AfterAgentHook, AfterModelHook, AgentMiddleware, AnyAnnotationRoot, ApproveDecision, BaseMessage, BaseMessageChunk, BeforeAgentHook, BeforeModelHook, type BrowserTool, type BrowserToolParams, BuiltInPIIType, BuiltInState, ClearToolUsesEdit, ClearToolUsesEditConfig, type ContentBlock, ContextEdit, ContextEditingMiddlewareConfig, CreateAgentParams, Decision, DecisionType, DescriptionFactory, Document, type DocumentInput, DynamicStructuredTool, DynamicSystemPromptMiddlewareConfig, DynamicTool, EditDecision, ExecutedToolCall, ExtractZodArrayTypes, FakeToolCallingModel, HITLRequest, HITLResponse, HumanInTheLoopMiddlewareConfig, HumanMessage, HumanMessageChunk, InMemoryStore, InferChannelType, InferContextInput, InferMergedInputState, InferMergedState, InferMiddlewareContext, InferMiddlewareContextInput, InferMiddlewareContextInputs, InferMiddlewareContexts, InferMiddlewareInputState, InferMiddlewareInputStates, InferMiddlewareState, InferMiddlewareStates, InferSchemaInput, Interrupt, InterruptOnConfig, JumpTo, JumpToTarget, LLMToolSelectorConfig, MIDDLEWARE_BRAND, MiddlewareResult, ModelCallLimitMiddlewareConfig, ModelRetryMiddlewareConfig, MultipleStructuredOutputsError, MultipleToolsBoundError, N, NormalizedSchemaInput, OpenAIModerationMiddlewareOptions, PIIDetectionError, PIIDetector, PIIMatch, PIIMiddlewareConfig, PIIRedactionMiddlewareConfig, PIIStrategy, PromptCachingMiddlewareConfig, ProviderStrategy, ReactAgent, RedactionRuleConfig, RejectDecision, ResolvedRedactionRule, ResponseFormat, ResponseFormatUndefined, ReviewConfig, Runtime, StructuredOutputParsingError, StructuredTool, SummarizationMiddlewareConfig, SystemMessage, SystemMessageChunk, TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT, ToAnnotationRoot, TodoListMiddlewareOptions, TokenCounter, Tool, ToolCall, ToolCallHandler, ToolCallLimitConfig, ToolCallLimitExceededError, ToolCallRequest, ToolEmulatorOptions, ToolInvocationError, ToolMessage, ToolMessageChunk, ToolResult, ToolRetryMiddlewareConfig, type ToolRuntime, ToolStrategy, UserInput, WithStateGraphNodes, WrapModelCallHandler, WrapModelCallHook, WrapToolCallHook, anthropicPromptCachingMiddleware, applyStrategy, browserTool, context, contextEditingMiddleware, countTokensApproximately, createAgent, createMiddleware, detectCreditCard, detectEmail, detectIP, detectMacAddress, detectUrl, dynamicSystemPromptMiddleware, filterMessages, humanInTheLoopMiddleware, initChatModel, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, modelRetryMiddleware, openAIModerationMiddleware, piiMiddleware, piiRedactionMiddleware, providerStrategy, resolveRedactionRule, summarizationMiddleware, todoListMiddleware, tool, toolCallLimitMiddleware, toolEmulatorMiddleware, toolRetryMiddleware, toolStrategy, trimMessages };

package/dist/index.js

@@ -1,5 +1,6 @@
 import { __export } from "./_virtual/rolldown_runtime.js";
 import { initChatModel } from "./chat_models/universal.js";
+import { browserTool } from "./tools/browser.js";
 import { MultipleStructuredOutputsError, MultipleToolsBoundError, StructuredOutputParsingError, ToolInvocationError } from "./agents/errors.js";
 import { ProviderStrategy, ToolStrategy, providerStrategy, toolStrategy } from "./agents/responses.js";
 import { countTokensApproximately } from "./agents/middleware/utils.js";
@@ -26,6 +27,7 @@ import { anthropicPromptCachingMiddleware } from "./agents/middleware/provider/a
 import "./agents/middleware/index.js";
 import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, filterMessages, trimMessages } from "@langchain/core/messages";
 import { DynamicStructuredTool, DynamicTool, StructuredTool, Tool, tool } from "@langchain/core/tools";
+import { context } from "@langchain/core/utils/context";
 import { InMemoryStore } from "@langchain/core/stores";
 import { Document } from "@langchain/core/documents";
 
@@ -62,6 +64,8 @@ __export(src_exports, {
 	ToolStrategy: () => ToolStrategy,
 	anthropicPromptCachingMiddleware: () => anthropicPromptCachingMiddleware,
 	applyStrategy: () => applyStrategy,
+	browserTool: () => browserTool,
+	context: () => context,
 	contextEditingMiddleware: () => contextEditingMiddleware,
 	countTokensApproximately: () => countTokensApproximately,
 	createAgent: () => createAgent,
@@ -95,5 +99,5 @@ __export(src_exports, {
 });
 
 //#endregion
-export { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ClearToolUsesEdit, Document, DynamicStructuredTool, DynamicTool, FakeToolCallingModel, HumanMessage, HumanMessageChunk, InMemoryStore, MIDDLEWARE_BRAND, MultipleStructuredOutputsError, MultipleToolsBoundError, PIIDetectionError, ProviderStrategy, StructuredOutputParsingError, StructuredTool, SystemMessage, SystemMessageChunk, TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT, Tool, ToolCallLimitExceededError, ToolInvocationError, ToolMessage, ToolMessageChunk, ToolStrategy, anthropicPromptCachingMiddleware, applyStrategy, contextEditingMiddleware, countTokensApproximately, createAgent, createMiddleware, detectCreditCard, detectEmail, detectIP, detectMacAddress, detectUrl, dynamicSystemPromptMiddleware, filterMessages, humanInTheLoopMiddleware, initChatModel, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, modelRetryMiddleware, openAIModerationMiddleware, piiMiddleware, piiRedactionMiddleware, providerStrategy, resolveRedactionRule, src_exports, summarizationMiddleware, todoListMiddleware, tool, toolCallLimitMiddleware, toolEmulatorMiddleware, toolRetryMiddleware, toolStrategy, trimMessages };
+export { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ClearToolUsesEdit, Document, DynamicStructuredTool, DynamicTool, FakeToolCallingModel, HumanMessage, HumanMessageChunk, InMemoryStore, MIDDLEWARE_BRAND, MultipleStructuredOutputsError, MultipleToolsBoundError, PIIDetectionError, ProviderStrategy, StructuredOutputParsingError, StructuredTool, SystemMessage, SystemMessageChunk, TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT, Tool, ToolCallLimitExceededError, ToolInvocationError, ToolMessage, ToolMessageChunk, ToolStrategy, anthropicPromptCachingMiddleware, applyStrategy, browserTool, context, contextEditingMiddleware, countTokensApproximately, createAgent, createMiddleware, detectCreditCard, detectEmail, detectIP, detectMacAddress, detectUrl, dynamicSystemPromptMiddleware, filterMessages, humanInTheLoopMiddleware, initChatModel, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, modelRetryMiddleware, openAIModerationMiddleware, piiMiddleware, piiRedactionMiddleware, providerStrategy, resolveRedactionRule, src_exports, summarizationMiddleware, todoListMiddleware, tool, toolCallLimitMiddleware, toolEmulatorMiddleware, toolRetryMiddleware, 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  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 {\n  tool,\n  Tool,\n  type ToolRuntime,\n  DynamicTool,\n  StructuredTool,\n  DynamicStructuredTool,\n} from \"@langchain/core/tools\";\n\n/**\n * LangChain Agents\n */\nexport * from \"./agents/index.js\";\n\n/**\n * `createAgent` pre-built middleware\n */\nexport * from \"./agents/middleware/index.js\";\n\n/**\n * LangChain Stores\n */\nexport { InMemoryStore } from \"@langchain/core/stores\";\n\n/**\n * LangChain Documents\n */\nexport { type DocumentInput, 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 {\n  tool,\n  Tool,\n  type ToolRuntime,\n  DynamicTool,\n  StructuredTool,\n  DynamicStructuredTool,\n} from \"@langchain/core/tools\";\n\n/**\n * Browser Tools\n */\nexport {\n  browserTool,\n  type BrowserTool,\n  type BrowserToolParams,\n} from \"./tools/browser.js\";\n\n/**\n * LangChain utilities\n */\nexport { context } from \"@langchain/core/utils/context\";\n\n/**\n * LangChain Agents\n */\nexport * from \"./agents/index.js\";\n\n/**\n * `createAgent` pre-built middleware\n */\nexport * from \"./agents/middleware/index.js\";\n\n/**\n * LangChain Stores\n */\nexport { InMemoryStore } from \"@langchain/core/stores\";\n\n/**\n * LangChain Documents\n */\nexport { type DocumentInput, Document } from \"@langchain/core/documents\";\n"],"mappings":""}

package/dist/tools/browser.cjs

@@ -0,0 +1,81 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const __langchain_core_tools = require_rolldown_runtime.__toESM(require("@langchain/core/tools"));
+const __langchain_langgraph = require_rolldown_runtime.__toESM(require("@langchain/langgraph"));
+
+//#region src/tools/browser.ts
+/**
+* Check if we're running in a browser environment.
+*/
+const isBrowserEnvironment = () => typeof window !== "undefined" && typeof navigator !== "undefined" && typeof document !== "undefined";
+/**
+* Creates a browser tool that interrupts on the server and executes on the client.
+*
+* Browser tools are defined once and work in both environments:
+* - **Server**: Returns a `Command` that interrupts with the tool call details
+* - **Browser**: Executes the tool directly using browser APIs
+*
+* @example
+* ```typescript
+* import { browserTool } from "langchain/tools/browser";
+* import { z } from "zod";
+*
+* export const getLocation = browserTool({
+*   name: "get_location",
+*   description: "Get the user's current GPS location",
+*   schema: z.object({
+*     highAccuracy: z.boolean().optional().describe("Request high accuracy GPS"),
+*   }),
+*   execute: async ({ highAccuracy }) => {
+*     return new Promise((resolve, reject) => {
+*       navigator.geolocation.getCurrentPosition(
+*         (pos) => resolve({
+*           latitude: pos.coords.latitude,
+*           longitude: pos.coords.longitude,
+*         }),
+*         (err) => reject(new Error(err.message)),
+*         { enableHighAccuracy: highAccuracy }
+*       );
+*     });
+*   },
+* });
+*
+* // Use in createAgent (server)
+* const agent = createAgent({
+*   model: "openai:gpt-4o",
+*   tools: [getLocation],
+* });
+*
+* // Use in useStream (client)
+* const stream = useStream({
+*   assistantId: "agent",
+*   browserTools: [getLocation],
+* });
+* ```
+*
+* @param params - The browser tool configuration
+* @returns A browser tool that can be used in both environments
+*/
+function browserTool(params) {
+	const { execute, name, description, schema } = params;
+	const wrappedTool = (0, __langchain_core_tools.tool)(async (args, config) => {
+		if (isBrowserEnvironment()) return execute(args);
+		return (0, __langchain_langgraph.interrupt)({
+			type: "browser_tool",
+			toolCall: {
+				id: config?.toolCall?.id,
+				name,
+				args
+			}
+		});
+	}, {
+		name,
+		description,
+		schema,
+		metadata: { browserTool: true }
+	});
+	return Object.assign(wrappedTool, { execute });
+}
+
+//#endregion
+exports.browserTool = browserTool;
+//# sourceMappingURL=browser.cjs.map

package/dist/tools/browser.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.cjs","names":["params: BrowserToolParams<SchemaT, OutputT>","args: InferInteropZodOutput<SchemaT>","config?: ToolRunnableConfig"],"sources":["../../src/tools/browser.ts"],"sourcesContent":["/**\n * Browser Tools for LangChain Agents\n *\n * This module provides the `browserTool` primitive for creating tools that\n * execute in the browser while the agent runs on the server.\n *\n * @module\n */\n\nimport {\n  tool as coreTool,\n  DynamicStructuredTool,\n  type ToolRunnableConfig,\n} from \"@langchain/core/tools\";\nimport type {\n  InteropZodObject,\n  InferInteropZodOutput,\n} from \"@langchain/core/utils/types\";\nimport { interrupt } from \"@langchain/langgraph\";\n\n/**\n * Check if we're running in a browser environment.\n */\nconst isBrowserEnvironment = (): boolean =>\n  typeof window !== \"undefined\" &&\n  typeof navigator !== \"undefined\" &&\n  typeof document !== \"undefined\";\n\n/**\n * Parameters for creating a browser tool.\n */\nexport interface BrowserToolParams<\n  SchemaT extends InteropZodObject,\n  OutputT = unknown\n> {\n  /**\n   * The name of the tool. Must be unique across all tools.\n   */\n  name: string;\n\n  /**\n   * A description of what the tool does. This is shown to the LLM\n   * to help it decide when to use the tool.\n   */\n  description: string;\n\n  /**\n   * The Zod schema defining the input parameters for the tool.\n   */\n  schema: SchemaT;\n\n  /**\n   * The function that executes the tool in the browser.\n   * This function only runs in browser environments.\n   *\n   * @param args - The parsed input arguments matching the schema\n   * @returns The tool output\n   */\n  execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;\n}\n\n/**\n * A browser tool that can be used in both server and client environments.\n *\n * On the server, it returns a Command that interrupts execution.\n * On the client, it executes the tool directly.\n */\nexport type BrowserTool<\n  SchemaT extends InteropZodObject = InteropZodObject,\n  OutputT = unknown\n> = DynamicStructuredTool<SchemaT> & {\n  /**\n   * The execute function for client-side use.\n   * Called by `useStream` when the interrupt is received.\n   */\n  execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;\n};\n\n/**\n * Creates a browser tool that interrupts on the server and executes on the client.\n *\n * Browser tools are defined once and work in both environments:\n * - **Server**: Returns a `Command` that interrupts with the tool call details\n * - **Browser**: Executes the tool directly using browser APIs\n *\n * @example\n * ```typescript\n * import { browserTool } from \"langchain/tools/browser\";\n * import { z } from \"zod\";\n *\n * export const getLocation = browserTool({\n *   name: \"get_location\",\n *   description: \"Get the user's current GPS location\",\n *   schema: z.object({\n *     highAccuracy: z.boolean().optional().describe(\"Request high accuracy GPS\"),\n *   }),\n *   execute: async ({ highAccuracy }) => {\n *     return new Promise((resolve, reject) => {\n *       navigator.geolocation.getCurrentPosition(\n *         (pos) => resolve({\n *           latitude: pos.coords.latitude,\n *           longitude: pos.coords.longitude,\n *         }),\n *         (err) => reject(new Error(err.message)),\n *         { enableHighAccuracy: highAccuracy }\n *       );\n *     });\n *   },\n * });\n *\n * // Use in createAgent (server)\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getLocation],\n * });\n *\n * // Use in useStream (client)\n * const stream = useStream({\n *   assistantId: \"agent\",\n *   browserTools: [getLocation],\n * });\n * ```\n *\n * @param params - The browser tool configuration\n * @returns A browser tool that can be used in both environments\n */\nexport function browserTool<\n  SchemaT extends InteropZodObject,\n  OutputT = unknown\n>(params: BrowserToolParams<SchemaT, OutputT>): BrowserTool<SchemaT, OutputT> {\n  const { execute, name, description, schema } = params;\n\n  // Create the underlying tool using @langchain/core's tool function\n  const wrappedTool = coreTool(\n    async (\n      args: InferInteropZodOutput<SchemaT>,\n      config?: ToolRunnableConfig\n    ) => {\n      // In browser: execute the tool directly\n      if (isBrowserEnvironment()) {\n        return execute(args);\n      }\n\n      // On server: interrupt and wait for client to execute\n      // The interrupt value contains the tool call details for the client\n      return interrupt({\n        type: \"browser_tool\",\n        toolCall: {\n          id: config?.toolCall?.id,\n          name,\n          args,\n        },\n      });\n    },\n    {\n      name,\n      description,\n      schema,\n      // Mark as browser tool in metadata for detection\n      metadata: {\n        browserTool: true,\n      },\n    }\n  );\n\n  // Attach the execute function for explicit client-side use (e.g., in useStream)\n  return Object.assign(wrappedTool, { execute }) as BrowserTool<\n    SchemaT,\n    OutputT\n  >;\n}\n"],"mappings":";;;;;;;;AAuBA,MAAM,uBAAuB,MAC3B,OAAO,WAAW,eAClB,OAAO,cAAc,eACrB,OAAO,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoGtB,SAAgB,YAGdA,QAA4E;CAC5E,MAAM,EAAE,SAAS,MAAM,aAAa,QAAQ,GAAG;CAG/C,MAAM,+CACJ,OACEC,MACAC,WACG;AAEH,MAAI,sBAAsB,CACxB,QAAO,QAAQ,KAAK;AAKtB,8CAAiB;GACf,MAAM;GACN,UAAU;IACR,IAAI,QAAQ,UAAU;IACtB;IACA;GACD;EACF,EAAC;CACH,GACD;EACE;EACA;EACA;EAEA,UAAU,EACR,aAAa,KACd;CACF,EACF;AAGD,QAAO,OAAO,OAAO,aAAa,EAAE,QAAS,EAAC;AAI/C"}

package/dist/tools/browser.d.cts

@@ -0,0 +1,96 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { InferInteropZodOutput, InteropZodObject } from "@langchain/core/utils/types";
+
+//#region src/tools/browser.d.ts
+
+/**
+ * Parameters for creating a browser tool.
+ */
+interface BrowserToolParams<SchemaT extends InteropZodObject, OutputT = unknown> {
+  /**
+   * The name of the tool. Must be unique across all tools.
+   */
+  name: string;
+  /**
+   * A description of what the tool does. This is shown to the LLM
+   * to help it decide when to use the tool.
+   */
+  description: string;
+  /**
+   * The Zod schema defining the input parameters for the tool.
+   */
+  schema: SchemaT;
+  /**
+   * The function that executes the tool in the browser.
+   * This function only runs in browser environments.
+   *
+   * @param args - The parsed input arguments matching the schema
+   * @returns The tool output
+   */
+  execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;
+}
+/**
+ * A browser tool that can be used in both server and client environments.
+ *
+ * On the server, it returns a Command that interrupts execution.
+ * On the client, it executes the tool directly.
+ */
+type BrowserTool<SchemaT extends InteropZodObject = InteropZodObject, OutputT = unknown> = DynamicStructuredTool<SchemaT> & {
+  /**
+   * The execute function for client-side use.
+   * Called by `useStream` when the interrupt is received.
+   */
+  execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;
+};
+/**
+ * Creates a browser tool that interrupts on the server and executes on the client.
+ *
+ * Browser tools are defined once and work in both environments:
+ * - **Server**: Returns a `Command` that interrupts with the tool call details
+ * - **Browser**: Executes the tool directly using browser APIs
+ *
+ * @example
+ * ```typescript
+ * import { browserTool } from "langchain/tools/browser";
+ * import { z } from "zod";
+ *
+ * export const getLocation = browserTool({
+ *   name: "get_location",
+ *   description: "Get the user's current GPS location",
+ *   schema: z.object({
+ *     highAccuracy: z.boolean().optional().describe("Request high accuracy GPS"),
+ *   }),
+ *   execute: async ({ highAccuracy }) => {
+ *     return new Promise((resolve, reject) => {
+ *       navigator.geolocation.getCurrentPosition(
+ *         (pos) => resolve({
+ *           latitude: pos.coords.latitude,
+ *           longitude: pos.coords.longitude,
+ *         }),
+ *         (err) => reject(new Error(err.message)),
+ *         { enableHighAccuracy: highAccuracy }
+ *       );
+ *     });
+ *   },
+ * });
+ *
+ * // Use in createAgent (server)
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",
+ *   tools: [getLocation],
+ * });
+ *
+ * // Use in useStream (client)
+ * const stream = useStream({
+ *   assistantId: "agent",
+ *   browserTools: [getLocation],
+ * });
+ * ```
+ *
+ * @param params - The browser tool configuration
+ * @returns A browser tool that can be used in both environments
+ */
+declare function browserTool<SchemaT extends InteropZodObject, OutputT = unknown>(params: BrowserToolParams<SchemaT, OutputT>): BrowserTool<SchemaT, OutputT>;
+//#endregion
+export { BrowserTool, BrowserToolParams, browserTool };
+//# sourceMappingURL=browser.d.cts.map

package/dist/tools/browser.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.cts","names":["DynamicStructuredTool","InteropZodObject","InferInteropZodOutput","BrowserToolParams","SchemaT","OutputT","Promise","BrowserTool","browserTool"],"sources":["../../src/tools/browser.d.ts"],"sourcesContent":["/**\n * Browser Tools for LangChain Agents\n *\n * This module provides the `browserTool` primitive for creating tools that\n * execute in the browser while the agent runs on the server.\n *\n * @module\n */\nimport { DynamicStructuredTool } from \"@langchain/core/tools\";\nimport type { InteropZodObject, InferInteropZodOutput } from \"@langchain/core/utils/types\";\n/**\n * Parameters for creating a browser tool.\n */\nexport interface BrowserToolParams<SchemaT extends InteropZodObject, OutputT = unknown> {\n    /**\n     * The name of the tool. Must be unique across all tools.\n     */\n    name: string;\n    /**\n     * A description of what the tool does. This is shown to the LLM\n     * to help it decide when to use the tool.\n     */\n    description: string;\n    /**\n     * The Zod schema defining the input parameters for the tool.\n     */\n    schema: SchemaT;\n    /**\n     * The function that executes the tool in the browser.\n     * This function only runs in browser environments.\n     *\n     * @param args - The parsed input arguments matching the schema\n     * @returns The tool output\n     */\n    execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;\n}\n/**\n * A browser tool that can be used in both server and client environments.\n *\n * On the server, it returns a Command that interrupts execution.\n * On the client, it executes the tool directly.\n */\nexport type BrowserTool<SchemaT extends InteropZodObject = InteropZodObject, OutputT = unknown> = DynamicStructuredTool<SchemaT> & {\n    /**\n     * The execute function for client-side use.\n     * Called by `useStream` when the interrupt is received.\n     */\n    execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;\n};\n/**\n * Creates a browser tool that interrupts on the server and executes on the client.\n *\n * Browser tools are defined once and work in both environments:\n * - **Server**: Returns a `Command` that interrupts with the tool call details\n * - **Browser**: Executes the tool directly using browser APIs\n *\n * @example\n * ```typescript\n * import { browserTool } from \"langchain/tools/browser\";\n * import { z } from \"zod\";\n *\n * export const getLocation = browserTool({\n *   name: \"get_location\",\n *   description: \"Get the user's current GPS location\",\n *   schema: z.object({\n *     highAccuracy: z.boolean().optional().describe(\"Request high accuracy GPS\"),\n *   }),\n *   execute: async ({ highAccuracy }) => {\n *     return new Promise((resolve, reject) => {\n *       navigator.geolocation.getCurrentPosition(\n *         (pos) => resolve({\n *           latitude: pos.coords.latitude,\n *           longitude: pos.coords.longitude,\n *         }),\n *         (err) => reject(new Error(err.message)),\n *         { enableHighAccuracy: highAccuracy }\n *       );\n *     });\n *   },\n * });\n *\n * // Use in createAgent (server)\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getLocation],\n * });\n *\n * // Use in useStream (client)\n * const stream = useStream({\n *   assistantId: \"agent\",\n *   browserTools: [getLocation],\n * });\n * ```\n *\n * @param params - The browser tool configuration\n * @returns A browser tool that can be used in both environments\n */\nexport declare function browserTool<SchemaT extends InteropZodObject, OutputT = unknown>(params: BrowserToolParams<SchemaT, OutputT>): BrowserTool<SchemaT, OutputT>;\n//# sourceMappingURL=browser.d.ts.map"],"mappings":";;;;;;AAkC8D;AAQ9D;AAAwCC,UA7BvBE,iBA6BuBF,CAAAA,gBA7BWA,gBA6BXA,EAAAA,UAAAA,OAAAA,CAAAA,CAAAA;EAAmBA;;;EAKjBG,IAAAA,EAAAA,MAAAA;EAAtBF;;;AAA0C;EAkDtCM,WAAAA,EAAAA,MAAW;EAAiBP;;;EAA6CE,MAAAA,EAvErFC,OAuEqFD;EAAkDC;;;AAAD;;;;kBA/D9HF,sBAAsBE,aAAaE,QAAQD;;;;;;;;KAQnDE,4BAA4BN,mBAAmBA,uCAAuCD,sBAAsBI;;;;;kBAKpGF,sBAAsBE,aAAaE,QAAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDvCG,4BAA4BP,6CAA6CE,kBAAkBC,SAASC,WAAWE,YAAYH,SAASC"}

package/dist/tools/browser.d.ts

@@ -0,0 +1,96 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { InferInteropZodOutput, InteropZodObject } from "@langchain/core/utils/types";
+
+//#region src/tools/browser.d.ts
+
+/**
+ * Parameters for creating a browser tool.
+ */
+interface BrowserToolParams<SchemaT extends InteropZodObject, OutputT = unknown> {
+  /**
+   * The name of the tool. Must be unique across all tools.
+   */
+  name: string;
+  /**
+   * A description of what the tool does. This is shown to the LLM
+   * to help it decide when to use the tool.
+   */
+  description: string;
+  /**
+   * The Zod schema defining the input parameters for the tool.
+   */
+  schema: SchemaT;
+  /**
+   * The function that executes the tool in the browser.
+   * This function only runs in browser environments.
+   *
+   * @param args - The parsed input arguments matching the schema
+   * @returns The tool output
+   */
+  execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;
+}
+/**
+ * A browser tool that can be used in both server and client environments.
+ *
+ * On the server, it returns a Command that interrupts execution.
+ * On the client, it executes the tool directly.
+ */
+type BrowserTool<SchemaT extends InteropZodObject = InteropZodObject, OutputT = unknown> = DynamicStructuredTool<SchemaT> & {
+  /**
+   * The execute function for client-side use.
+   * Called by `useStream` when the interrupt is received.
+   */
+  execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;
+};
+/**
+ * Creates a browser tool that interrupts on the server and executes on the client.
+ *
+ * Browser tools are defined once and work in both environments:
+ * - **Server**: Returns a `Command` that interrupts with the tool call details
+ * - **Browser**: Executes the tool directly using browser APIs
+ *
+ * @example
+ * ```typescript
+ * import { browserTool } from "langchain/tools/browser";
+ * import { z } from "zod";
+ *
+ * export const getLocation = browserTool({
+ *   name: "get_location",
+ *   description: "Get the user's current GPS location",
+ *   schema: z.object({
+ *     highAccuracy: z.boolean().optional().describe("Request high accuracy GPS"),
+ *   }),
+ *   execute: async ({ highAccuracy }) => {
+ *     return new Promise((resolve, reject) => {
+ *       navigator.geolocation.getCurrentPosition(
+ *         (pos) => resolve({
+ *           latitude: pos.coords.latitude,
+ *           longitude: pos.coords.longitude,
+ *         }),
+ *         (err) => reject(new Error(err.message)),
+ *         { enableHighAccuracy: highAccuracy }
+ *       );
+ *     });
+ *   },
+ * });
+ *
+ * // Use in createAgent (server)
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",
+ *   tools: [getLocation],
+ * });
+ *
+ * // Use in useStream (client)
+ * const stream = useStream({
+ *   assistantId: "agent",
+ *   browserTools: [getLocation],
+ * });
+ * ```
+ *
+ * @param params - The browser tool configuration
+ * @returns A browser tool that can be used in both environments
+ */
+declare function browserTool<SchemaT extends InteropZodObject, OutputT = unknown>(params: BrowserToolParams<SchemaT, OutputT>): BrowserTool<SchemaT, OutputT>;
+//#endregion
+export { BrowserTool, BrowserToolParams, browserTool };
+//# sourceMappingURL=browser.d.ts.map

package/dist/tools/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","names":["DynamicStructuredTool","InteropZodObject","InferInteropZodOutput","BrowserToolParams","SchemaT","OutputT","Promise","BrowserTool","browserTool"],"sources":["../../src/tools/browser.d.ts"],"sourcesContent":["/**\n * Browser Tools for LangChain Agents\n *\n * This module provides the `browserTool` primitive for creating tools that\n * execute in the browser while the agent runs on the server.\n *\n * @module\n */\nimport { DynamicStructuredTool } from \"@langchain/core/tools\";\nimport type { InteropZodObject, InferInteropZodOutput } from \"@langchain/core/utils/types\";\n/**\n * Parameters for creating a browser tool.\n */\nexport interface BrowserToolParams<SchemaT extends InteropZodObject, OutputT = unknown> {\n    /**\n     * The name of the tool. Must be unique across all tools.\n     */\n    name: string;\n    /**\n     * A description of what the tool does. This is shown to the LLM\n     * to help it decide when to use the tool.\n     */\n    description: string;\n    /**\n     * The Zod schema defining the input parameters for the tool.\n     */\n    schema: SchemaT;\n    /**\n     * The function that executes the tool in the browser.\n     * This function only runs in browser environments.\n     *\n     * @param args - The parsed input arguments matching the schema\n     * @returns The tool output\n     */\n    execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;\n}\n/**\n * A browser tool that can be used in both server and client environments.\n *\n * On the server, it returns a Command that interrupts execution.\n * On the client, it executes the tool directly.\n */\nexport type BrowserTool<SchemaT extends InteropZodObject = InteropZodObject, OutputT = unknown> = DynamicStructuredTool<SchemaT> & {\n    /**\n     * The execute function for client-side use.\n     * Called by `useStream` when the interrupt is received.\n     */\n    execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;\n};\n/**\n * Creates a browser tool that interrupts on the server and executes on the client.\n *\n * Browser tools are defined once and work in both environments:\n * - **Server**: Returns a `Command` that interrupts with the tool call details\n * - **Browser**: Executes the tool directly using browser APIs\n *\n * @example\n * ```typescript\n * import { browserTool } from \"langchain/tools/browser\";\n * import { z } from \"zod\";\n *\n * export const getLocation = browserTool({\n *   name: \"get_location\",\n *   description: \"Get the user's current GPS location\",\n *   schema: z.object({\n *     highAccuracy: z.boolean().optional().describe(\"Request high accuracy GPS\"),\n *   }),\n *   execute: async ({ highAccuracy }) => {\n *     return new Promise((resolve, reject) => {\n *       navigator.geolocation.getCurrentPosition(\n *         (pos) => resolve({\n *           latitude: pos.coords.latitude,\n *           longitude: pos.coords.longitude,\n *         }),\n *         (err) => reject(new Error(err.message)),\n *         { enableHighAccuracy: highAccuracy }\n *       );\n *     });\n *   },\n * });\n *\n * // Use in createAgent (server)\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getLocation],\n * });\n *\n * // Use in useStream (client)\n * const stream = useStream({\n *   assistantId: \"agent\",\n *   browserTools: [getLocation],\n * });\n * ```\n *\n * @param params - The browser tool configuration\n * @returns A browser tool that can be used in both environments\n */\nexport declare function browserTool<SchemaT extends InteropZodObject, OutputT = unknown>(params: BrowserToolParams<SchemaT, OutputT>): BrowserTool<SchemaT, OutputT>;\n//# sourceMappingURL=browser.d.ts.map"],"mappings":";;;;;;AAkC8D;AAQ9D;AAAwCC,UA7BvBE,iBA6BuBF,CAAAA,gBA7BWA,gBA6BXA,EAAAA,UAAAA,OAAAA,CAAAA,CAAAA;EAAmBA;;;EAKjBG,IAAAA,EAAAA,MAAAA;EAAtBF;;;AAA0C;EAkDtCM,WAAAA,EAAAA,MAAW;EAAiBP;;;EAA6CE,MAAAA,EAvErFC,OAuEqFD;EAAkDC;;;AAAD;;;;kBA/D9HF,sBAAsBE,aAAaE,QAAQD;;;;;;;;KAQnDE,4BAA4BN,mBAAmBA,uCAAuCD,sBAAsBI;;;;;kBAKpGF,sBAAsBE,aAAaE,QAAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDvCG,4BAA4BP,6CAA6CE,kBAAkBC,SAASC,WAAWE,YAAYH,SAASC"}

package/dist/tools/browser.js

@@ -0,0 +1,80 @@
+import { tool } from "@langchain/core/tools";
+import { interrupt } from "@langchain/langgraph";
+
+//#region src/tools/browser.ts
+/**
+* Check if we're running in a browser environment.
+*/
+const isBrowserEnvironment = () => typeof window !== "undefined" && typeof navigator !== "undefined" && typeof document !== "undefined";
+/**
+* Creates a browser tool that interrupts on the server and executes on the client.
+*
+* Browser tools are defined once and work in both environments:
+* - **Server**: Returns a `Command` that interrupts with the tool call details
+* - **Browser**: Executes the tool directly using browser APIs
+*
+* @example
+* ```typescript
+* import { browserTool } from "langchain/tools/browser";
+* import { z } from "zod";
+*
+* export const getLocation = browserTool({
+*   name: "get_location",
+*   description: "Get the user's current GPS location",
+*   schema: z.object({
+*     highAccuracy: z.boolean().optional().describe("Request high accuracy GPS"),
+*   }),
+*   execute: async ({ highAccuracy }) => {
+*     return new Promise((resolve, reject) => {
+*       navigator.geolocation.getCurrentPosition(
+*         (pos) => resolve({
+*           latitude: pos.coords.latitude,
+*           longitude: pos.coords.longitude,
+*         }),
+*         (err) => reject(new Error(err.message)),
+*         { enableHighAccuracy: highAccuracy }
+*       );
+*     });
+*   },
+* });
+*
+* // Use in createAgent (server)
+* const agent = createAgent({
+*   model: "openai:gpt-4o",
+*   tools: [getLocation],
+* });
+*
+* // Use in useStream (client)
+* const stream = useStream({
+*   assistantId: "agent",
+*   browserTools: [getLocation],
+* });
+* ```
+*
+* @param params - The browser tool configuration
+* @returns A browser tool that can be used in both environments
+*/
+function browserTool(params) {
+	const { execute, name, description, schema } = params;
+	const wrappedTool = tool(async (args, config) => {
+		if (isBrowserEnvironment()) return execute(args);
+		return interrupt({
+			type: "browser_tool",
+			toolCall: {
+				id: config?.toolCall?.id,
+				name,
+				args
+			}
+		});
+	}, {
+		name,
+		description,
+		schema,
+		metadata: { browserTool: true }
+	});
+	return Object.assign(wrappedTool, { execute });
+}
+
+//#endregion
+export { browserTool };
+//# sourceMappingURL=browser.js.map