@langchain/core 0.3.55 → 0.3.56

package/dist/runnables/remote.cjs

@@ -239,6 +239,8 @@ function serialize(input) {
  * `.invoke()`, `.stream()`, `.streamEvents()`, etc. methods that
  * other runnables support.
  *
+ * @deprecated LangServe is no longer actively developed - please consider using LangGraph Platform.
+ *
  * @param url - The base URL of the LangServe endpoint.
  * @param options - Optional configuration for the remote runnable, including timeout and headers.
  * @param fetch - Optional custom fetch implementation.

package/dist/runnables/remote.d.ts

@@ -15,6 +15,8 @@ type RemoteRunnableOptions = {
  * `.invoke()`, `.stream()`, `.streamEvents()`, etc. methods that
  * other runnables support.
  *
+ * @deprecated LangServe is no longer actively developed - please consider using LangGraph Platform.
+ *
  * @param url - The base URL of the LangServe endpoint.
  * @param options - Optional configuration for the remote runnable, including timeout and headers.
  * @param fetch - Optional custom fetch implementation.

package/dist/runnables/remote.js

@@ -236,6 +236,8 @@ function serialize(input) {
  * `.invoke()`, `.stream()`, `.streamEvents()`, etc. methods that
  * other runnables support.
  *
+ * @deprecated LangServe is no longer actively developed - please consider using LangGraph Platform.
+ *
  * @param url - The base URL of the LangServe endpoint.
  * @param options - Optional configuration for the remote runnable, including timeout and headers.
  * @param fetch - Optional custom fetch implementation.

package/dist/tracers/tracer_langchain.cjs

@@ -151,7 +151,10 @@ class LangChainTracer extends base_js_1.BaseTracer {
     }
     static getTraceableRunTree() {
         try {
-            return (0, traceable_1.getCurrentRunTree)();
+            return (
+            // The type cast here provides forward compatibility. Old versions of LangSmith will just
+            // ignore the permitAbsentRunTree arg.
+            traceable_1.getCurrentRunTree(true));
         }
         catch {
             return undefined;

package/dist/tracers/tracer_langchain.js

@@ -148,7 +148,10 @@ export class LangChainTracer extends BaseTracer {
     }
     static getTraceableRunTree() {
         try {
-            return getCurrentRunTree();
+            return (
+            // The type cast here provides forward compatibility. Old versions of LangSmith will just
+            // ignore the permitAbsentRunTree arg.
+            getCurrentRunTree(true));
         }
         catch {
             return undefined;

package/dist/utils/testing/helpers.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.charChunks = void 0;
+const index_js_1 = require("../../messages/index.cjs");
+/** Tiny helper to convert string into char chunk. For eg: Turn `"Hi!"` into `[AIMessageChunk("H"), AIMessageChunk("i"), AIMessageChunk("!")] */
+const charChunks = (text) => [...text].map((c) => new index_js_1.AIMessageChunk({ content: c }));
+exports.charChunks = charChunks;

package/dist/utils/testing/helpers.d.ts

@@ -0,0 +1,3 @@
+import { AIMessageChunk } from "../../messages/index.js";
+/** Tiny helper to convert string into char chunk. For eg: Turn `"Hi!"` into `[AIMessageChunk("H"), AIMessageChunk("i"), AIMessageChunk("!")] */
+export declare const charChunks: (text: string) => AIMessageChunk[];

package/dist/utils/testing/helpers.js

@@ -0,0 +1,3 @@
+import { AIMessageChunk } from "../../messages/index.js";
+/** Tiny helper to convert string into char chunk. For eg: Turn `"Hi!"` into `[AIMessageChunk("H"), AIMessageChunk("i"), AIMessageChunk("!")] */
+export const charChunks = (text) => [...text].map((c) => new AIMessageChunk({ content: c }));

package/dist/utils/testing/index.cjs

@@ -16,6 +16,7 @@ const base_js_2 = require("../../runnables/base.cjs");
 const index_js_3 = require("../../tools/index.cjs");
 const base_js_3 = require("../../tracers/base.cjs");
 const embeddings_js_1 = require("../../embeddings.cjs");
+const json_schema_js_1 = require("../json_schema.cjs");
 const vectorstores_js_1 = require("../../vectorstores.cjs");
 const similarities_js_1 = require("../ml-distance/similarities.cjs");
 /**
@@ -186,8 +187,8 @@ class FakeChatModel extends chat_models_js_1.BaseChatModel {
 }
 exports.FakeChatModel = FakeChatModel;
 class FakeStreamingChatModel extends chat_models_js_1.BaseChatModel {
-    constructor(fields) {
-        super(fields);
+    constructor({ sleep = 50, responses = [], chunks = [], toolStyle = "openai", thrownErrorString, ...rest }) {
+        super(rest);
         Object.defineProperty(this, "sleep", {
             enumerable: true,
             configurable: true,
@@ -198,7 +199,19 @@ class FakeStreamingChatModel extends chat_models_js_1.BaseChatModel {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: []
+        });
+        Object.defineProperty(this, "chunks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "toolStyle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "openai"
         });
         Object.defineProperty(this, "thrownErrorString", {
             enumerable: true,
@@ -206,54 +219,120 @@ class FakeStreamingChatModel extends chat_models_js_1.BaseChatModel {
             writable: true,
             value: void 0
         });
-        this.sleep = fields.sleep ?? this.sleep;
-        this.responses = fields.responses;
-        this.thrownErrorString = fields.thrownErrorString;
+        Object.defineProperty(this, "tools", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.sleep = sleep;
+        this.responses = responses;
+        this.chunks = chunks;
+        this.toolStyle = toolStyle;
+        this.thrownErrorString = thrownErrorString;
     }
     _llmType() {
         return "fake";
     }
+    bindTools(tools) {
+        const merged = [...this.tools, ...tools];
+        const toolDicts = merged.map((t) => {
+            switch (this.toolStyle) {
+                case "openai":
+                    return {
+                        type: "function",
+                        function: {
+                            name: t.name,
+                            description: t.description,
+                            parameters: (0, json_schema_js_1.toJsonSchema)(t.schema),
+                        },
+                    };
+                case "anthropic":
+                    return {
+                        name: t.name,
+                        description: t.description,
+                        input_schema: (0, json_schema_js_1.toJsonSchema)(t.schema),
+                    };
+                case "bedrock":
+                    return {
+                        toolSpec: {
+                            name: t.name,
+                            description: t.description,
+                            inputSchema: (0, json_schema_js_1.toJsonSchema)(t.schema),
+                        },
+                    };
+                case "google":
+                    return {
+                        name: t.name,
+                        description: t.description,
+                        parameters: (0, json_schema_js_1.toJsonSchema)(t.schema),
+                    };
+                default:
+                    throw new Error(`Unsupported tool style: ${this.toolStyle}`);
+            }
+        });
+        const wrapped = this.toolStyle === "google"
+            ? [{ functionDeclarations: toolDicts }]
+            : toolDicts;
+        /* creating a *new* instance – mirrors LangChain .bind semantics for type-safety and avoiding noise */
+        const next = new FakeStreamingChatModel({
+            sleep: this.sleep,
+            responses: this.responses,
+            chunks: this.chunks,
+            toolStyle: this.toolStyle,
+            thrownErrorString: this.thrownErrorString,
+        });
+        next.tools = merged;
+        return next.bind({ tools: wrapped });
+    }
     async _generate(messages, _options, _runManager) {
         if (this.thrownErrorString) {
             throw new Error(this.thrownErrorString);
         }
-        const content = this.responses?.[0].content ?? messages[0].content;
+        const content = this.responses?.[0]?.content ?? messages[0].content ?? "";
         const generation = {
             generations: [
                 {
                     text: "",
                     message: new index_js_1.AIMessage({
                         content,
+                        tool_calls: this.chunks?.[0]?.tool_calls,
                     }),
                 },
             ],
         };
         return generation;
     }
-    async *_streamResponseChunks(messages, _options, _runManager) {
+    async *_streamResponseChunks(_messages, _options, runManager) {
         if (this.thrownErrorString) {
             throw new Error(this.thrownErrorString);
         }
-        const content = this.responses?.[0].content ?? messages[0].content;
-        if (typeof content !== "string") {
-            for (const _ of this.responses ?? messages) {
-                yield new outputs_js_1.ChatGenerationChunk({
-                    text: "",
+        if (this.chunks?.length) {
+            for (const msgChunk of this.chunks) {
+                const cg = new outputs_js_1.ChatGenerationChunk({
                     message: new index_js_1.AIMessageChunk({
-                        content,
+                        content: msgChunk.content,
+                        tool_calls: msgChunk.tool_calls,
+                        additional_kwargs: msgChunk.additional_kwargs ?? {},
                     }),
+                    text: msgChunk.content?.toString() ?? "",
                 });
+                yield cg;
+                await runManager?.handleLLMNewToken(msgChunk.content, undefined, undefined, undefined, undefined, { chunk: cg });
             }
+            return;
         }
-        else {
-            for (const _ of this.responses ?? messages) {
-                yield new outputs_js_1.ChatGenerationChunk({
-                    text: content,
-                    message: new index_js_1.AIMessageChunk({
-                        content,
-                    }),
-                });
-            }
+        const fallback = this.responses?.[0] ??
+            new index_js_1.AIMessage(typeof _messages[0].content === "string" ? _messages[0].content : "");
+        const text = typeof fallback.content === "string" ? fallback.content : "";
+        for (const ch of text) {
+            await new Promise((r) => setTimeout(r, this.sleep));
+            const cg = new outputs_js_1.ChatGenerationChunk({
+                message: new index_js_1.AIMessageChunk({ content: ch }),
+                text: ch,
+            });
+            yield cg;
+            await runManager?.handleLLMNewToken(ch, undefined, undefined, undefined, undefined, { chunk: cg });
         }
     }
 }
@@ -430,7 +509,13 @@ class FakeListChatModel extends chat_models_js_1.BaseChatModel {
     withStructuredOutput(_params, _config) {
         return base_js_2.RunnableLambda.from(async (input) => {
             const message = await this.invoke(input);
-            return JSON.parse(message.content);
+            if (message.tool_calls?.[0]?.args) {
+                return message.tool_calls[0].args;
+            }
+            if (typeof message.content === "string") {
+                return JSON.parse(message.content);
+            }
+            throw new Error("No structured output found");
         });
     }
 }

package/dist/utils/testing/index.d.ts

@@ -4,7 +4,7 @@ import { BaseChatMessageHistory, BaseListChatMessageHistory } from "../../chat_h
 import { Document } from "../../documents/document.js";
 import { BaseChatModel, BaseChatModelCallOptions, BaseChatModelParams } from "../../language_models/chat_models.js";
 import { BaseLLMParams, LLM } from "../../language_models/llms.js";
-import { BaseMessage, AIMessage } from "../../messages/index.js";
+import { BaseMessage, AIMessage, AIMessageChunk } from "../../messages/index.js";
 import { BaseOutputParser } from "../../output_parsers/base.js";
 import { GenerationChunk, type ChatResult, ChatGenerationChunk } from "../../outputs.js";
 import { BaseRetriever } from "../../retrievers/index.js";
@@ -60,18 +60,18 @@ export declare class FakeChatModel extends BaseChatModel {
     _llmType(): string;
     _generate(messages: BaseMessage[], options?: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
 }
-export declare class FakeStreamingChatModel extends BaseChatModel {
-    sleep?: number;
-    responses?: BaseMessage[];
+export declare class FakeStreamingChatModel extends BaseChatModel<FakeStreamingChatModelCallOptions> {
+    sleep: number;
+    responses: BaseMessage[];
+    chunks: AIMessageChunk[];
+    toolStyle: "openai" | "anthropic" | "bedrock" | "google";
     thrownErrorString?: string;
-    constructor(fields: {
-        sleep?: number;
-        responses?: BaseMessage[];
-        thrownErrorString?: string;
-    } & BaseLLMParams);
+    private tools;
+    constructor({ sleep, responses, chunks, toolStyle, thrownErrorString, ...rest }: FakeStreamingChatModelFields & BaseLLMParams);
     _llmType(): string;
+    bindTools(tools: (StructuredTool | ToolSpec)[]): Runnable<BaseLanguageModelInput, AIMessageChunk, FakeStreamingChatModelCallOptions>;
     _generate(messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-    _streamResponseChunks(messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }
 export declare class FakeRetriever extends BaseRetriever {
     lc_namespace: string[];
@@ -81,6 +81,32 @@ export declare class FakeRetriever extends BaseRetriever {
     });
     _getRelevantDocuments(_query: string): Promise<Document<Record<string, any>>[]>;
 }
+/** Minimal shape actually needed by `bindTools` */
+export interface ToolSpec {
+    name: string;
+    description?: string;
+    schema: z.ZodTypeAny | Record<string, unknown>;
+}
+/**
+ * Interface specific to the Fake Streaming Chat model.
+ */
+export interface FakeStreamingChatModelCallOptions extends BaseChatModelCallOptions {
+}
+/**
+ * Interface for the Constructor-field specific to the Fake Streaming Chat model (all optional because we fill in defaults).
+ */
+export interface FakeStreamingChatModelFields extends BaseChatModelParams {
+    /** Milliseconds to pause between fallback char-by-char chunks */
+    sleep?: number;
+    /** Full AI messages to fall back to when no `chunks` supplied */
+    responses?: BaseMessage[];
+    /** Exact chunks to emit (can include tool-call deltas) */
+    chunks?: AIMessageChunk[];
+    /** How tool specs are formatted in `bindTools` */
+    toolStyle?: "openai" | "anthropic" | "bedrock" | "google";
+    /** Throw this error instead of streaming (useful in tests) */
+    thrownErrorString?: string;
+}
 /**
  * Interface for the input parameters specific to the Fake List Chat model.
  */

package/dist/utils/testing/index.js

@@ -13,6 +13,7 @@ import { Runnable, RunnableLambda } from "../../runnables/base.js";
 import { StructuredTool } from "../../tools/index.js";
 import { BaseTracer } from "../../tracers/base.js";
 import { Embeddings, } from "../../embeddings.js";
+import { toJsonSchema } from "../json_schema.js";
 import { VectorStore } from "../../vectorstores.js";
 import { cosine } from "../ml-distance/similarities.js";
 /**
@@ -178,8 +179,8 @@ export class FakeChatModel extends BaseChatModel {
     }
 }
 export class FakeStreamingChatModel extends BaseChatModel {
-    constructor(fields) {
-        super(fields);
+    constructor({ sleep = 50, responses = [], chunks = [], toolStyle = "openai", thrownErrorString, ...rest }) {
+        super(rest);
         Object.defineProperty(this, "sleep", {
             enumerable: true,
             configurable: true,
@@ -190,7 +191,19 @@ export class FakeStreamingChatModel extends BaseChatModel {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: []
+        });
+        Object.defineProperty(this, "chunks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "toolStyle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "openai"
         });
         Object.defineProperty(this, "thrownErrorString", {
             enumerable: true,
@@ -198,54 +211,120 @@ export class FakeStreamingChatModel extends BaseChatModel {
             writable: true,
             value: void 0
         });
-        this.sleep = fields.sleep ?? this.sleep;
-        this.responses = fields.responses;
-        this.thrownErrorString = fields.thrownErrorString;
+        Object.defineProperty(this, "tools", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.sleep = sleep;
+        this.responses = responses;
+        this.chunks = chunks;
+        this.toolStyle = toolStyle;
+        this.thrownErrorString = thrownErrorString;
     }
     _llmType() {
         return "fake";
     }
+    bindTools(tools) {
+        const merged = [...this.tools, ...tools];
+        const toolDicts = merged.map((t) => {
+            switch (this.toolStyle) {
+                case "openai":
+                    return {
+                        type: "function",
+                        function: {
+                            name: t.name,
+                            description: t.description,
+                            parameters: toJsonSchema(t.schema),
+                        },
+                    };
+                case "anthropic":
+                    return {
+                        name: t.name,
+                        description: t.description,
+                        input_schema: toJsonSchema(t.schema),
+                    };
+                case "bedrock":
+                    return {
+                        toolSpec: {
+                            name: t.name,
+                            description: t.description,
+                            inputSchema: toJsonSchema(t.schema),
+                        },
+                    };
+                case "google":
+                    return {
+                        name: t.name,
+                        description: t.description,
+                        parameters: toJsonSchema(t.schema),
+                    };
+                default:
+                    throw new Error(`Unsupported tool style: ${this.toolStyle}`);
+            }
+        });
+        const wrapped = this.toolStyle === "google"
+            ? [{ functionDeclarations: toolDicts }]
+            : toolDicts;
+        /* creating a *new* instance – mirrors LangChain .bind semantics for type-safety and avoiding noise */
+        const next = new FakeStreamingChatModel({
+            sleep: this.sleep,
+            responses: this.responses,
+            chunks: this.chunks,
+            toolStyle: this.toolStyle,
+            thrownErrorString: this.thrownErrorString,
+        });
+        next.tools = merged;
+        return next.bind({ tools: wrapped });
+    }
     async _generate(messages, _options, _runManager) {
         if (this.thrownErrorString) {
             throw new Error(this.thrownErrorString);
         }
-        const content = this.responses?.[0].content ?? messages[0].content;
+        const content = this.responses?.[0]?.content ?? messages[0].content ?? "";
         const generation = {
             generations: [
                 {
                     text: "",
                     message: new AIMessage({
                         content,
+                        tool_calls: this.chunks?.[0]?.tool_calls,
                     }),
                 },
             ],
         };
         return generation;
     }
-    async *_streamResponseChunks(messages, _options, _runManager) {
+    async *_streamResponseChunks(_messages, _options, runManager) {
         if (this.thrownErrorString) {
             throw new Error(this.thrownErrorString);
         }
-        const content = this.responses?.[0].content ?? messages[0].content;
-        if (typeof content !== "string") {
-            for (const _ of this.responses ?? messages) {
-                yield new ChatGenerationChunk({
-                    text: "",
+        if (this.chunks?.length) {
+            for (const msgChunk of this.chunks) {
+                const cg = new ChatGenerationChunk({
                     message: new AIMessageChunk({
-                        content,
+                        content: msgChunk.content,
+                        tool_calls: msgChunk.tool_calls,
+                        additional_kwargs: msgChunk.additional_kwargs ?? {},
                     }),
+                    text: msgChunk.content?.toString() ?? "",
                 });
+                yield cg;
+                await runManager?.handleLLMNewToken(msgChunk.content, undefined, undefined, undefined, undefined, { chunk: cg });
             }
+            return;
         }
-        else {
-            for (const _ of this.responses ?? messages) {
-                yield new ChatGenerationChunk({
-                    text: content,
-                    message: new AIMessageChunk({
-                        content,
-                    }),
-                });
-            }
+        const fallback = this.responses?.[0] ??
+            new AIMessage(typeof _messages[0].content === "string" ? _messages[0].content : "");
+        const text = typeof fallback.content === "string" ? fallback.content : "";
+        for (const ch of text) {
+            await new Promise((r) => setTimeout(r, this.sleep));
+            const cg = new ChatGenerationChunk({
+                message: new AIMessageChunk({ content: ch }),
+                text: ch,
+            });
+            yield cg;
+            await runManager?.handleLLMNewToken(ch, undefined, undefined, undefined, undefined, { chunk: cg });
         }
     }
 }
@@ -420,7 +499,13 @@ export class FakeListChatModel extends BaseChatModel {
     withStructuredOutput(_params, _config) {
         return RunnableLambda.from(async (input) => {
             const message = await this.invoke(input);
-            return JSON.parse(message.content);
+            if (message.tool_calls?.[0]?.args) {
+                return message.tool_calls[0].args;
+            }
+            if (typeof message.content === "string") {
+                return JSON.parse(message.content);
+            }
+            throw new Error("No structured output found");
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.3.55",
+  "version": "0.3.56",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -38,7 +38,7 @@
     "camelcase": "6",
     "decamelize": "1.2.0",
     "js-tiktoken": "^1.0.12",
-    "langsmith": "^0.3.16",
+    "langsmith": "^0.3.29",
     "mustache": "^4.2.0",
     "p-queue": "^6.6.2",
     "p-retry": "4",