langchain 1.2.2 → 1.2.3-dev-1766775128110

package/dist/tools/browser.d.cts

@@ -0,0 +1,77 @@
+import { DynamicStructuredTool, ToolWrapperParams } from "@langchain/core/tools";
+import { InferInteropZodOutput, InteropZodObject } from "@langchain/core/utils/types";
+
+//#region src/tools/browser.d.ts
+
+/**
+ * Configuration fields for creating a browser tool.
+ */
+type BrowserToolFields<SchemaT extends InteropZodObject> = ToolWrapperParams<SchemaT> & Required<Pick<ToolWrapperParams<SchemaT>, "description" | "schema">>;
+/**
+ * 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(
+ *   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 }
+ *       );
+ *     });
+ *   },
+ *   {
+ *     name: "get_location",
+ *     description: "Get the user's current GPS location",
+ *     schema: z.object({
+ *       highAccuracy: z.boolean().optional().describe("Request high accuracy GPS"),
+ *     }),
+ *   }
+ * );
+ *
+ * // 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 execute - The function that executes the tool in the browser
+ * @param fields - The tool configuration (name, description, schema)
+ * @returns A browser tool that can be used in both environments
+ */
+declare function browserTool<SchemaT extends InteropZodObject, OutputT = unknown>(execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>, fields: BrowserToolFields<SchemaT>): BrowserTool<SchemaT, OutputT>;
+//#endregion
+export { BrowserTool, BrowserToolFields, browserTool };
+//# sourceMappingURL=browser.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.cts","names":["DynamicStructuredTool","ToolWrapperParams","InteropZodObject","InferInteropZodOutput","BrowserToolFields","SchemaT","Pick","Required","BrowserTool","OutputT","Promise","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, type ToolWrapperParams } from \"@langchain/core/tools\";\nimport type { InteropZodObject, InferInteropZodOutput } from \"@langchain/core/utils/types\";\n/**\n * Configuration fields for creating a browser tool.\n */\nexport type BrowserToolFields<SchemaT extends InteropZodObject> = ToolWrapperParams<SchemaT> & Required<Pick<ToolWrapperParams<SchemaT>, \"description\" | \"schema\">>;\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 *   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 *     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 *   }\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 execute - The function that executes the tool in the browser\n * @param fields - The tool configuration (name, description, schema)\n * @returns A browser tool that can be used in both environments\n */\nexport declare function browserTool<SchemaT extends InteropZodObject, OutputT = unknown>(execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>, fields: BrowserToolFields<SchemaT>): BrowserTool<SchemaT, OutputT>;\n//# sourceMappingURL=browser.d.ts.map"],"mappings":";;;;;;;AAauG;AAO3FQ,KAPAJ,iBAOWC,CAAAA,gBAPuBH,gBAOvB,CAAA,GAP2CD,iBAO3C,CAP6DI,OAO7D,CAAA,GAPwEE,QAOxE,CAPiFD,IAOjF,CAPsFL,iBAOtF,CAPwGI,OAOxG,CAAA,EAAA,aAAA,GAAA,QAAA,CAAA,CAAA;;;;;;;AAKwCI,KALnDD,WAKmDC,CAAAA,gBALvBP,gBAKuBO,GALJP,gBAKIO,EAAAA,UAAAA,OAAAA,CAAAA,GALmCT,qBAKnCS,CALyDJ,OAKzDI,CAAAA,GAAAA;EAARC;AAAO;AAqD9D;;EAA+HL,OAAAA,EAAAA,CAAAA,IAAAA,EArD3GF,qBAqD2GE,CArDrFA,OAqDqFA,CAAAA,EAAAA,GArDxEK,OAqDwEL,CArDhEI,OAqDgEJ,CAAAA;CAAtBF;;;;;;;;AAAqG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAtLQ,4BAA4BT,qDAAqDC,sBAAsBE,aAAaK,QAAQD,kBAAkBL,kBAAkBC,WAAWG,YAAYH,SAASI"}

package/dist/tools/browser.d.ts

@@ -0,0 +1,77 @@
+import { DynamicStructuredTool, ToolWrapperParams } from "@langchain/core/tools";
+import { InferInteropZodOutput, InteropZodObject } from "@langchain/core/utils/types";
+
+//#region src/tools/browser.d.ts
+
+/**
+ * Configuration fields for creating a browser tool.
+ */
+type BrowserToolFields<SchemaT extends InteropZodObject> = ToolWrapperParams<SchemaT> & Required<Pick<ToolWrapperParams<SchemaT>, "description" | "schema">>;
+/**
+ * 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(
+ *   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 }
+ *       );
+ *     });
+ *   },
+ *   {
+ *     name: "get_location",
+ *     description: "Get the user's current GPS location",
+ *     schema: z.object({
+ *       highAccuracy: z.boolean().optional().describe("Request high accuracy GPS"),
+ *     }),
+ *   }
+ * );
+ *
+ * // 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 execute - The function that executes the tool in the browser
+ * @param fields - The tool configuration (name, description, schema)
+ * @returns A browser tool that can be used in both environments
+ */
+declare function browserTool<SchemaT extends InteropZodObject, OutputT = unknown>(execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>, fields: BrowserToolFields<SchemaT>): BrowserTool<SchemaT, OutputT>;
+//#endregion
+export { BrowserTool, BrowserToolFields, browserTool };
+//# sourceMappingURL=browser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","names":["DynamicStructuredTool","ToolWrapperParams","InteropZodObject","InferInteropZodOutput","BrowserToolFields","SchemaT","Pick","Required","BrowserTool","OutputT","Promise","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, type ToolWrapperParams } from \"@langchain/core/tools\";\nimport type { InteropZodObject, InferInteropZodOutput } from \"@langchain/core/utils/types\";\n/**\n * Configuration fields for creating a browser tool.\n */\nexport type BrowserToolFields<SchemaT extends InteropZodObject> = ToolWrapperParams<SchemaT> & Required<Pick<ToolWrapperParams<SchemaT>, \"description\" | \"schema\">>;\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 *   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 *     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 *   }\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 execute - The function that executes the tool in the browser\n * @param fields - The tool configuration (name, description, schema)\n * @returns A browser tool that can be used in both environments\n */\nexport declare function browserTool<SchemaT extends InteropZodObject, OutputT = unknown>(execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>, fields: BrowserToolFields<SchemaT>): BrowserTool<SchemaT, OutputT>;\n//# sourceMappingURL=browser.d.ts.map"],"mappings":";;;;;;;AAauG;AAO3FQ,KAPAJ,iBAOWC,CAAAA,gBAPuBH,gBAOvB,CAAA,GAP2CD,iBAO3C,CAP6DI,OAO7D,CAAA,GAPwEE,QAOxE,CAPiFD,IAOjF,CAPsFL,iBAOtF,CAPwGI,OAOxG,CAAA,EAAA,aAAA,GAAA,QAAA,CAAA,CAAA;;;;;;;AAKwCI,KALnDD,WAKmDC,CAAAA,gBALvBP,gBAKuBO,GALJP,gBAKIO,EAAAA,UAAAA,OAAAA,CAAAA,GALmCT,qBAKnCS,CALyDJ,OAKzDI,CAAAA,GAAAA;EAARC;AAAO;AAqD9D;;EAA+HL,OAAAA,EAAAA,CAAAA,IAAAA,EArD3GF,qBAqD2GE,CArDrFA,OAqDqFA,CAAAA,EAAAA,GArDxEK,OAqDwEL,CArDhEI,OAqDgEJ,CAAAA;CAAtBF;;;;;;;;AAAqG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAtLQ,4BAA4BT,qDAAqDC,sBAAsBE,aAAaK,QAAQD,kBAAkBL,kBAAkBC,WAAWG,YAAYH,SAASI"}

package/dist/tools/browser.js

@@ -0,0 +1,83 @@
+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(
+*   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 }
+*       );
+*     });
+*   },
+*   {
+*     name: "get_location",
+*     description: "Get the user's current GPS location",
+*     schema: z.object({
+*       highAccuracy: z.boolean().optional().describe("Request high accuracy GPS"),
+*     }),
+*   }
+* );
+*
+* // 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 execute - The function that executes the tool in the browser
+* @param fields - The tool configuration (name, description, schema)
+* @returns A browser tool that can be used in both environments
+*/
+function browserTool(execute, fields) {
+	const { name, description, schema } = fields;
+	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":["execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>","fields: BrowserToolFields<SchemaT>","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  type ToolWrapperParams,\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 * Configuration fields for creating a browser tool.\n */\nexport type BrowserToolFields<SchemaT extends InteropZodObject> =\n  ToolWrapperParams<SchemaT> &\n    Required<Pick<ToolWrapperParams<SchemaT>, \"description\" | \"schema\">>;\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 *   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 *     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 *   }\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 execute - The function that executes the tool in the browser\n * @param fields - The tool configuration (name, description, schema)\n * @returns A browser tool that can be used in both environments\n */\nexport function browserTool<\n  SchemaT extends InteropZodObject,\n  OutputT = unknown\n>(\n  execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>,\n  fields: BrowserToolFields<SchemaT>\n): BrowserTool<SchemaT, OutputT> {\n  const { name, description, schema } = fields;\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":";;;;;;;AAwBA,MAAM,uBAAuB,MAC3B,OAAO,WAAW,eAClB,OAAO,cAAc,eACrB,OAAO,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6EtB,SAAgB,YAIdA,SACAC,QAC+B;CAC/B,MAAM,EAAE,MAAM,aAAa,QAAQ,GAAG;CAGtC,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-1766775128110",
   "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-1766775128110",
     "@langchain/cohere": "1.0.1",
-    "@langchain/core": "1.1.7",
+    "@langchain/core": "1.1.8-dev-1766775128110",
     "@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-1766775128110"
   },
   "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");

package/load.d.cts

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

package/load.d.ts

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

package/load.js

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

package/storage/encoder_backed.cjs

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

package/storage/encoder_backed.d.cts

@@ -1 +0,0 @@
-export * from "../dist/storage/encoder_backed.js";

package/storage/encoder_backed.d.ts

@@ -1 +0,0 @@
-export * from "../dist/storage/encoder_backed.js";

package/storage/encoder_backed.js

@@ -1 +0,0 @@
-export * from "../dist/storage/encoder_backed.js";

package/storage/file_system.cjs

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

package/storage/file_system.d.cts

@@ -1 +0,0 @@
-export * from "../dist/storage/file_system.js";

package/storage/file_system.d.ts

@@ -1 +0,0 @@
-export * from "../dist/storage/file_system.js";

package/storage/file_system.js

@@ -1 +0,0 @@
-export * from "../dist/storage/file_system.js";

package/storage/in_memory.cjs

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

package/storage/in_memory.d.cts

@@ -1 +0,0 @@
-export * from "../dist/storage/in_memory.js";

package/storage/in_memory.d.ts

@@ -1 +0,0 @@
-export * from "../dist/storage/in_memory.js";

package/storage/in_memory.js

@@ -1 +0,0 @@
-export * from "../dist/storage/in_memory.js";