langchain 1.2.2 → 1.2.3-dev-1766726832377

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":["__types_js6","BaseMessage","AfterModelHook","AfterAgentHook","BeforeAgentHook","BeforeModelHook","JumpToTarget","countTokensApproximately","getHookConstraint","getHookFunction","___runtime_js0","AgentBuiltInState","Runtime","Partial","MiddlewareResult","Promise","sleep","calculateRetryDelay"],"sources":["../../../src/agents/middleware/utils.d.ts"],"sourcesContent":["import { type BaseMessage } from \"@langchain/core/messages\";\nimport { AfterModelHook, AfterAgentHook, BeforeAgentHook, BeforeModelHook } from \"./types.js\";\nimport { JumpToTarget } from \"../constants.js\";\n/**\n * Default token counter that approximates based on character count\n * @param messages Messages to count tokens for\n * @returns Approximate token count\n */\nexport declare function countTokensApproximately(messages: BaseMessage[]): number;\nexport declare function getHookConstraint(hook: BeforeAgentHook | BeforeModelHook | AfterAgentHook | AfterModelHook | undefined): JumpToTarget[] | undefined;\nexport declare function getHookFunction(arg: BeforeAgentHook | BeforeModelHook | AfterAgentHook | AfterModelHook): ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>) | ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>) | ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>) | ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>);\n/**\n * Sleep for the specified number of milliseconds.\n */\nexport declare function sleep(ms: number): Promise<void>;\n/**\n * Calculate delay for a retry attempt with exponential backoff and jitter.\n *\n * @param retryNumber - The retry attempt number (0-indexed)\n * @param config - Configuration for backoff calculation\n * @returns Delay in milliseconds before next retry\n *\n * @internal Exported for testing purposes\n */\nexport declare function calculateRetryDelay(config: {\n    backoffFactor: number;\n    initialDelayMs: number;\n    maxDelayMs: number;\n    jitter: boolean;\n}, retryNumber: number): number;\n//# sourceMappingURL=utils.d.ts.map"],"mappings":";;;;;;;;AAQA;;;iBAAwBO,wBAAAA,WAAmCN"}
+{"version":3,"file":"utils.d.ts","names":["__types_js0","BaseMessage","AfterModelHook","AfterAgentHook","BeforeAgentHook","BeforeModelHook","JumpToTarget","countTokensApproximately","getHookConstraint","getHookFunction","___runtime_js0","AgentBuiltInState","Runtime","Partial","MiddlewareResult","Promise","sleep","calculateRetryDelay"],"sources":["../../../src/agents/middleware/utils.d.ts"],"sourcesContent":["import { type BaseMessage } from \"@langchain/core/messages\";\nimport { AfterModelHook, AfterAgentHook, BeforeAgentHook, BeforeModelHook } from \"./types.js\";\nimport { JumpToTarget } from \"../constants.js\";\n/**\n * Default token counter that approximates based on character count\n * @param messages Messages to count tokens for\n * @returns Approximate token count\n */\nexport declare function countTokensApproximately(messages: BaseMessage[]): number;\nexport declare function getHookConstraint(hook: BeforeAgentHook | BeforeModelHook | AfterAgentHook | AfterModelHook | undefined): JumpToTarget[] | undefined;\nexport declare function getHookFunction(arg: BeforeAgentHook | BeforeModelHook | AfterAgentHook | AfterModelHook): ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>) | ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>) | ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>) | ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>);\n/**\n * Sleep for the specified number of milliseconds.\n */\nexport declare function sleep(ms: number): Promise<void>;\n/**\n * Calculate delay for a retry attempt with exponential backoff and jitter.\n *\n * @param retryNumber - The retry attempt number (0-indexed)\n * @param config - Configuration for backoff calculation\n * @returns Delay in milliseconds before next retry\n *\n * @internal Exported for testing purposes\n */\nexport declare function calculateRetryDelay(config: {\n    backoffFactor: number;\n    initialDelayMs: number;\n    maxDelayMs: number;\n    jitter: boolean;\n}, retryNumber: number): number;\n//# sourceMappingURL=utils.d.ts.map"],"mappings":";;;;;;;;AAQA;;;iBAAwBO,wBAAAA,WAAmCN"}

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');
@@ -63,6 +64,7 @@ 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,
@@ -207,6 +209,7 @@ 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 () {

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 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":""}
+{"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";
@@ -31,4 +32,4 @@ import { DynamicStructuredTool, DynamicTool, StructuredTool, Tool, ToolRuntime,
 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, 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 };
+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";
@@ -32,4 +33,4 @@ import { DynamicStructuredTool, DynamicTool, StructuredTool, Tool, ToolRuntime,
 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, 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 };
+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";
@@ -63,6 +64,7 @@ __export(src_exports, {
 	ToolStrategy: () => ToolStrategy,
 	anthropicPromptCachingMiddleware: () => anthropicPromptCachingMiddleware,
 	applyStrategy: () => applyStrategy,
+	browserTool: () => browserTool,
 	context: () => context,
 	contextEditingMiddleware: () => contextEditingMiddleware,
 	countTokensApproximately: () => countTokensApproximately,
@@ -97,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, 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 };
+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 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":""}
+{"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

package/dist/tools/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.js","names":["params: BrowserToolParams<SchemaT, OutputT>","coreTool","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,cAAcC,KAClB,OACEC,MACAC,WACG;AAEH,MAAI,sBAAsB,CACxB,QAAO,QAAQ,KAAK;AAKtB,SAAO,UAAU;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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langchain",
-  "version": "1.2.2",
+  "version": "1.2.3-dev-1766726832377",
   "description": "Typescript bindings for langchain",
   "author": "LangChain",
   "license": "MIT",
@@ -53,15 +53,15 @@
     "typescript": "~5.8.3",
     "vitest": "^3.2.4",
     "yaml": "^2.8.1",
-    "@langchain/anthropic": "1.3.2",
+    "@langchain/anthropic": "1.3.3-dev-1766726832377",
     "@langchain/cohere": "1.0.1",
-    "@langchain/core": "1.1.7",
+    "@langchain/core": "1.1.8-dev-1766726832377",
     "@langchain/eslint": "0.1.1",
     "@langchain/openai": "1.2.0",
     "@langchain/tsconfig": "0.0.1"
   },
   "peerDependencies": {
-    "@langchain/core": "1.1.7"
+    "@langchain/core": "1.1.8-dev-1766726832377"
   },
   "dependencies": {
     "@langchain/langgraph": "^1.0.0",

package/chat_models/universal.cjs

@@ -1 +0,0 @@
-module.exports = require("../dist/chat_models/universal.cjs");

package/chat_models/universal.d.cts

@@ -1 +0,0 @@
-export * from "../dist/chat_models/universal.js";

package/chat_models/universal.d.ts

@@ -1 +0,0 @@
-export * from "../dist/chat_models/universal.js";

package/chat_models/universal.js

@@ -1 +0,0 @@
-export * from "../dist/chat_models/universal.js";

package/hub/node.cjs

@@ -1 +0,0 @@
-module.exports = require("../dist/hub/node.cjs");

package/hub/node.d.cts

@@ -1 +0,0 @@
-export * from "../dist/hub/node.js";

package/hub/node.d.ts

@@ -1 +0,0 @@
-export * from "../dist/hub/node.js";

package/hub/node.js

@@ -1 +0,0 @@
-export * from "../dist/hub/node.js";

package/hub.cjs

@@ -1 +0,0 @@
-module.exports = require("./dist/hub/index.cjs");

package/hub.d.cts

@@ -1 +0,0 @@
-export * from "./dist/hub/index.js";

package/hub.d.ts

@@ -1 +0,0 @@
-export * from "./dist/hub/index.js";

package/hub.js

@@ -1 +0,0 @@
-export * from "./dist/hub/index.js";

package/load/serializable.cjs

@@ -1 +0,0 @@
-module.exports = require("../dist/load/serializable.cjs");

package/load/serializable.d.cts

@@ -1 +0,0 @@
-export * from "../dist/load/serializable.js";

package/load/serializable.d.ts

@@ -1 +0,0 @@
-export * from "../dist/load/serializable.js";

package/load/serializable.js

@@ -1 +0,0 @@
-export * from "../dist/load/serializable.js";

package/load.cjs

@@ -1 +0,0 @@
-module.exports = require("./dist/load/index.cjs");