@langchain/core 0.2.16 → 0.2.18-rc.0

package/dist/callbacks/manager.cjs

@@ -9,8 +9,9 @@ const env_js_1 = require("../utils/env.cjs");
 const tracer_langchain_js_1 = require("../tracers/tracer_langchain.cjs");
 const promises_js_1 = require("./promises.cjs");
 const callbacks_js_1 = require("../utils/callbacks.cjs");
+const base_js_2 = require("../tracers/base.cjs");
 if (
-/* #__PURE__ */ (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_TRACING_V2") === "true" &&
+/* #__PURE__ */ (0, callbacks_js_1.isTracingEnabled)() &&
     /* #__PURE__ */ (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_CALLBACKS_BACKGROUND") !==
         "true") {
     /* #__PURE__ */ console.warn([
@@ -417,8 +418,17 @@ class CallbackManager extends BaseCallbackManager {
         return Promise.all(prompts.map(async (prompt, idx) => {
             // Can't have duplicate runs with the same run ID (if provided)
             const runId_ = idx === 0 && runId ? runId : (0, uuid_1.v4)();
-            await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
-                if (!handler.ignoreLLM) {
+            await Promise.all(this.handlers.map((handler) => {
+                if (handler.ignoreLLM) {
+                    return;
+                }
+                if ((0, base_js_2.isBaseTracer)(handler)) {
+                    // Create and add run to the run map.
+                    // We do this synchronously to avoid race conditions
+                    // when callbacks are backgrounded.
+                    handler._createRunForLLMStart(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+                }
+                return (0, promises_js_1.consumeCallback)(async () => {
                     try {
                         await handler.handleLLMStart?.(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
                     }
@@ -428,8 +438,8 @@ class CallbackManager extends BaseCallbackManager {
                             throw err;
                         }
                     }
-                }
-            }, handler.awaitHandlers)));
+                }, handler.awaitHandlers);
+            }));
             return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
         }));
     }
@@ -437,8 +447,17 @@ class CallbackManager extends BaseCallbackManager {
         return Promise.all(messages.map(async (messageGroup, idx) => {
             // Can't have duplicate runs with the same run ID (if provided)
             const runId_ = idx === 0 && runId ? runId : (0, uuid_1.v4)();
-            await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
-                if (!handler.ignoreLLM) {
+            await Promise.all(this.handlers.map((handler) => {
+                if (handler.ignoreLLM) {
+                    return;
+                }
+                if ((0, base_js_2.isBaseTracer)(handler)) {
+                    // Create and add run to the run map.
+                    // We do this synchronously to avoid race conditions
+                    // when callbacks are backgrounded.
+                    handler._createRunForChatModelStart(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+                }
+                return (0, promises_js_1.consumeCallback)(async () => {
                     try {
                         if (handler.handleChatModelStart) {
                             await handler.handleChatModelStart?.(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
@@ -454,14 +473,23 @@ class CallbackManager extends BaseCallbackManager {
                             throw err;
                         }
                     }
-                }
-            }, handler.awaitHandlers)));
+                }, handler.awaitHandlers);
+            }));
             return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
         }));
     }
     async handleChainStart(chain, inputs, runId = (0, uuid_1.v4)(), runType = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
-            if (!handler.ignoreChain) {
+        await Promise.all(this.handlers.map((handler) => {
+            if (handler.ignoreChain) {
+                return;
+            }
+            if ((0, base_js_2.isBaseTracer)(handler)) {
+                // Create and add run to the run map.
+                // We do this synchronously to avoid race conditions
+                // when callbacks are backgrounded.
+                handler._createRunForChainStart(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName);
+            }
+            return (0, promises_js_1.consumeCallback)(async () => {
                 try {
                     await handler.handleChainStart?.(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName);
                 }
@@ -471,13 +499,22 @@ class CallbackManager extends BaseCallbackManager {
                         throw err;
                     }
                 }
-            }
-        }, handler.awaitHandlers)));
+            }, handler.awaitHandlers);
+        }));
         return new CallbackManagerForChainRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
     }
     async handleToolStart(tool, input, runId = (0, uuid_1.v4)(), _parentRunId = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
-            if (!handler.ignoreAgent) {
+        await Promise.all(this.handlers.map((handler) => {
+            if (handler.ignoreAgent) {
+                return;
+            }
+            if ((0, base_js_2.isBaseTracer)(handler)) {
+                // Create and add run to the run map.
+                // We do this synchronously to avoid race conditions
+                // when callbacks are backgrounded.
+                handler._createRunForToolStart(tool, input, runId, this._parentRunId, this.tags, this.metadata, runName);
+            }
+            return (0, promises_js_1.consumeCallback)(async () => {
                 try {
                     await handler.handleToolStart?.(tool, input, runId, this._parentRunId, this.tags, this.metadata, runName);
                 }
@@ -487,13 +524,22 @@ class CallbackManager extends BaseCallbackManager {
                         throw err;
                     }
                 }
-            }
-        }, handler.awaitHandlers)));
+            }, handler.awaitHandlers);
+        }));
         return new CallbackManagerForToolRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
     }
     async handleRetrieverStart(retriever, query, runId = (0, uuid_1.v4)(), _parentRunId = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
-            if (!handler.ignoreRetriever) {
+        await Promise.all(this.handlers.map((handler) => {
+            if (handler.ignoreRetriever) {
+                return;
+            }
+            if ((0, base_js_2.isBaseTracer)(handler)) {
+                // Create and add run to the run map.
+                // We do this synchronously to avoid race conditions
+                // when callbacks are backgrounded.
+                handler._createRunForRetrieverStart(retriever, query, runId, this._parentRunId, this.tags, this.metadata, runName);
+            }
+            return (0, promises_js_1.consumeCallback)(async () => {
                 try {
                     await handler.handleRetrieverStart?.(retriever, query, runId, this._parentRunId, this.tags, this.metadata, runName);
                 }
@@ -503,8 +549,8 @@ class CallbackManager extends BaseCallbackManager {
                         throw err;
                     }
                 }
-            }
-        }, handler.awaitHandlers)));
+            }, handler.awaitHandlers);
+        }));
         return new CallbackManagerForRetrieverRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
     }
     async handleCustomEvent(eventName, 
@@ -629,7 +675,8 @@ class CallbackManager extends BaseCallbackManager {
         }
         const verboseEnabled = (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_VERBOSE") === "true" ||
             options?.verbose;
-        const tracingV2Enabled = (0, callbacks_js_1.isTracingEnabled)();
+        const tracingV2Enabled = tracer_langchain_js_1.LangChainTracer.getTraceableRunTree()?.tracingEnabled ||
+            (0, callbacks_js_1.isTracingEnabled)();
         const tracingEnabled = tracingV2Enabled ||
             ((0, env_js_1.getEnvironmentVariable)("LANGCHAIN_TRACING") ?? false);
         if (verboseEnabled || tracingEnabled) {
@@ -649,7 +696,8 @@ class CallbackManager extends BaseCallbackManager {
                     // handoff between langchain and langsmith/traceable
                     // override the parent run ID
                     callbackManager._parentRunId =
-                        tracerV2.getTraceableRunTree()?.id ?? callbackManager._parentRunId;
+                        tracer_langchain_js_1.LangChainTracer.getTraceableRunTree()?.id ??
+                            callbackManager._parentRunId;
                 }
             }
         }

package/dist/callbacks/manager.js

@@ -6,8 +6,9 @@ import { getEnvironmentVariable } from "../utils/env.js";
 import { LangChainTracer, } from "../tracers/tracer_langchain.js";
 import { consumeCallback } from "./promises.js";
 import { isTracingEnabled } from "../utils/callbacks.js";
+import { isBaseTracer } from "../tracers/base.js";
 if (
-/* #__PURE__ */ getEnvironmentVariable("LANGCHAIN_TRACING_V2") === "true" &&
+/* #__PURE__ */ isTracingEnabled() &&
     /* #__PURE__ */ getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") !==
         "true") {
     /* #__PURE__ */ console.warn([
@@ -407,8 +408,17 @@ export class CallbackManager extends BaseCallbackManager {
         return Promise.all(prompts.map(async (prompt, idx) => {
             // Can't have duplicate runs with the same run ID (if provided)
             const runId_ = idx === 0 && runId ? runId : uuidv4();
-            await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
-                if (!handler.ignoreLLM) {
+            await Promise.all(this.handlers.map((handler) => {
+                if (handler.ignoreLLM) {
+                    return;
+                }
+                if (isBaseTracer(handler)) {
+                    // Create and add run to the run map.
+                    // We do this synchronously to avoid race conditions
+                    // when callbacks are backgrounded.
+                    handler._createRunForLLMStart(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+                }
+                return consumeCallback(async () => {
                     try {
                         await handler.handleLLMStart?.(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
                     }
@@ -418,8 +428,8 @@ export class CallbackManager extends BaseCallbackManager {
                             throw err;
                         }
                     }
-                }
-            }, handler.awaitHandlers)));
+                }, handler.awaitHandlers);
+            }));
             return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
         }));
     }
@@ -427,8 +437,17 @@ export class CallbackManager extends BaseCallbackManager {
         return Promise.all(messages.map(async (messageGroup, idx) => {
             // Can't have duplicate runs with the same run ID (if provided)
             const runId_ = idx === 0 && runId ? runId : uuidv4();
-            await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
-                if (!handler.ignoreLLM) {
+            await Promise.all(this.handlers.map((handler) => {
+                if (handler.ignoreLLM) {
+                    return;
+                }
+                if (isBaseTracer(handler)) {
+                    // Create and add run to the run map.
+                    // We do this synchronously to avoid race conditions
+                    // when callbacks are backgrounded.
+                    handler._createRunForChatModelStart(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+                }
+                return consumeCallback(async () => {
                     try {
                         if (handler.handleChatModelStart) {
                             await handler.handleChatModelStart?.(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
@@ -444,14 +463,23 @@ export class CallbackManager extends BaseCallbackManager {
                             throw err;
                         }
                     }
-                }
-            }, handler.awaitHandlers)));
+                }, handler.awaitHandlers);
+            }));
             return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
         }));
     }
     async handleChainStart(chain, inputs, runId = uuidv4(), runType = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
-            if (!handler.ignoreChain) {
+        await Promise.all(this.handlers.map((handler) => {
+            if (handler.ignoreChain) {
+                return;
+            }
+            if (isBaseTracer(handler)) {
+                // Create and add run to the run map.
+                // We do this synchronously to avoid race conditions
+                // when callbacks are backgrounded.
+                handler._createRunForChainStart(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName);
+            }
+            return consumeCallback(async () => {
                 try {
                     await handler.handleChainStart?.(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName);
                 }
@@ -461,13 +489,22 @@ export class CallbackManager extends BaseCallbackManager {
                         throw err;
                     }
                 }
-            }
-        }, handler.awaitHandlers)));
+            }, handler.awaitHandlers);
+        }));
         return new CallbackManagerForChainRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
     }
     async handleToolStart(tool, input, runId = uuidv4(), _parentRunId = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
-            if (!handler.ignoreAgent) {
+        await Promise.all(this.handlers.map((handler) => {
+            if (handler.ignoreAgent) {
+                return;
+            }
+            if (isBaseTracer(handler)) {
+                // Create and add run to the run map.
+                // We do this synchronously to avoid race conditions
+                // when callbacks are backgrounded.
+                handler._createRunForToolStart(tool, input, runId, this._parentRunId, this.tags, this.metadata, runName);
+            }
+            return consumeCallback(async () => {
                 try {
                     await handler.handleToolStart?.(tool, input, runId, this._parentRunId, this.tags, this.metadata, runName);
                 }
@@ -477,13 +514,22 @@ export class CallbackManager extends BaseCallbackManager {
                         throw err;
                     }
                 }
-            }
-        }, handler.awaitHandlers)));
+            }, handler.awaitHandlers);
+        }));
         return new CallbackManagerForToolRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
     }
     async handleRetrieverStart(retriever, query, runId = uuidv4(), _parentRunId = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
-            if (!handler.ignoreRetriever) {
+        await Promise.all(this.handlers.map((handler) => {
+            if (handler.ignoreRetriever) {
+                return;
+            }
+            if (isBaseTracer(handler)) {
+                // Create and add run to the run map.
+                // We do this synchronously to avoid race conditions
+                // when callbacks are backgrounded.
+                handler._createRunForRetrieverStart(retriever, query, runId, this._parentRunId, this.tags, this.metadata, runName);
+            }
+            return consumeCallback(async () => {
                 try {
                     await handler.handleRetrieverStart?.(retriever, query, runId, this._parentRunId, this.tags, this.metadata, runName);
                 }
@@ -493,8 +539,8 @@ export class CallbackManager extends BaseCallbackManager {
                         throw err;
                     }
                 }
-            }
-        }, handler.awaitHandlers)));
+            }, handler.awaitHandlers);
+        }));
         return new CallbackManagerForRetrieverRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
     }
     async handleCustomEvent(eventName, 
@@ -619,7 +665,8 @@ export class CallbackManager extends BaseCallbackManager {
         }
         const verboseEnabled = getEnvironmentVariable("LANGCHAIN_VERBOSE") === "true" ||
             options?.verbose;
-        const tracingV2Enabled = isTracingEnabled();
+        const tracingV2Enabled = LangChainTracer.getTraceableRunTree()?.tracingEnabled ||
+            isTracingEnabled();
         const tracingEnabled = tracingV2Enabled ||
             (getEnvironmentVariable("LANGCHAIN_TRACING") ?? false);
         if (verboseEnabled || tracingEnabled) {
@@ -639,7 +686,8 @@ export class CallbackManager extends BaseCallbackManager {
                     // handoff between langchain and langsmith/traceable
                     // override the parent run ID
                     callbackManager._parentRunId =
-                        tracerV2.getTraceableRunTree()?.id ?? callbackManager._parentRunId;
+                        LangChainTracer.getTraceableRunTree()?.id ??
+                            callbackManager._parentRunId;
                 }
             }
         }

package/dist/callbacks/tests/callbacks.test.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-promise-executor-return */
 import { test, expect } from "@jest/globals";
 import * as uuid from "uuid";
 import { CallbackManager } from "../manager.js";
@@ -227,6 +228,8 @@ test("CallbackManager", async () => {
         new Document({ pageContent: "test", metadata: { test: "test" } }),
     ]);
     await retrieverCb.handleRetrieverError(new Error("test"));
+    // In case background mode is on while running this test
+    await new Promise((resolve) => setTimeout(resolve, 100));
     for (const handler of [handler1, handler2]) {
         expect(handler.starts).toBe(5);
         expect(handler.ends).toBe(5);

package/dist/language_models/chat_models.d.ts

@@ -8,6 +8,7 @@ import type { RunnableConfig } from "../runnables/config.js";
 import type { BaseCache } from "../caches/base.js";
 import { StructuredToolInterface } from "../tools/index.js";
 import { Runnable, RunnableToolLike } from "../runnables/base.js";
+type ToolChoice = string | Record<string, any> | "auto" | "any";
 /**
  * Represents a serialized chat model.
  */
@@ -29,7 +30,23 @@ export type BaseChatModelParams = BaseLanguageModelParams;
 /**
  * Represents the call options for a base chat model.
  */
-export type BaseChatModelCallOptions = BaseLanguageModelCallOptions;
+export type BaseChatModelCallOptions = BaseLanguageModelCallOptions & {
+    /**
+     * Specifies how the chat model should use tools.
+     * @default undefined
+     *
+     * Possible values:
+     * - "auto": The model may choose to use any of the provided tools, or none.
+     * - "any": The model must use one of the provided tools.
+     * - "none": The model must not use any tools.
+     * - A string (not "auto", "any", or "none"): The name of a specific tool the model must use.
+     * - An object: A custom schema specifying tool choice parameters. Specific to the provider.
+     *
+     * Note: Not all providers support tool_choice. An error will be thrown
+     * if used with an unsupported model.
+     */
+    tool_choice?: ToolChoice;
+};
 /**
  * Creates a transform stream for encoding chat message chunks.
  * @deprecated Use {@link BytesOutputParser} instead

package/dist/messages/ai.cjs

@@ -98,6 +98,14 @@ class AIMessage extends base_js_1.BaseMessage {
     _getType() {
         return "ai";
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            tool_calls: this.tool_calls,
+            invalid_tool_calls: this.invalid_tool_calls,
+            usage_metadata: this.usage_metadata,
+        };
+    }
 }
 exports.AIMessage = AIMessage;
 function isAIMessage(x) {
@@ -215,6 +223,15 @@ class AIMessageChunk extends base_js_1.BaseMessageChunk {
     _getType() {
         return "ai";
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            tool_calls: this.tool_calls,
+            tool_call_chunks: this.tool_call_chunks,
+            invalid_tool_calls: this.invalid_tool_calls,
+            usage_metadata: this.usage_metadata,
+        };
+    }
     concat(chunk) {
         const combinedFields = {
             content: (0, base_js_1.mergeContent)(this.content, chunk.content),

package/dist/messages/ai.d.ts

@@ -38,6 +38,7 @@ export declare class AIMessage extends BaseMessage {
     kwargs?: Record<string, unknown>);
     static lc_name(): string;
     _getType(): MessageType;
+    get _printableFields(): Record<string, unknown>;
 }
 export declare function isAIMessage(x: BaseMessage): x is AIMessage;
 export type AIMessageChunkFields = AIMessageFields & {
@@ -59,5 +60,6 @@ export declare class AIMessageChunk extends BaseMessageChunk {
     get lc_aliases(): Record<string, string>;
     static lc_name(): string;
     _getType(): MessageType;
+    get _printableFields(): Record<string, unknown>;
     concat(chunk: AIMessageChunk): AIMessageChunk;
 }

package/dist/messages/ai.js

@@ -95,6 +95,14 @@ export class AIMessage extends BaseMessage {
     _getType() {
         return "ai";
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            tool_calls: this.tool_calls,
+            invalid_tool_calls: this.invalid_tool_calls,
+            usage_metadata: this.usage_metadata,
+        };
+    }
 }
 export function isAIMessage(x) {
     return x._getType() === "ai";
@@ -210,6 +218,15 @@ export class AIMessageChunk extends BaseMessageChunk {
     _getType() {
         return "ai";
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            tool_calls: this.tool_calls,
+            tool_call_chunks: this.tool_call_chunks,
+            invalid_tool_calls: this.invalid_tool_calls,
+            usage_metadata: this.usage_metadata,
+        };
+    }
     concat(chunk) {
         const combinedFields = {
             content: mergeContent(this.content, chunk.content),

package/dist/messages/base.cjs

@@ -25,6 +25,30 @@ function mergeContent(firstContent, secondContent) {
     }
 }
 exports.mergeContent = mergeContent;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function stringifyWithDepthLimit(obj, depthLimit) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function helper(obj, currentDepth) {
+        if (typeof obj !== "object" || obj === null || obj === undefined) {
+            return obj;
+        }
+        if (currentDepth >= depthLimit) {
+            if (Array.isArray(obj)) {
+                return "[Array]";
+            }
+            return "[Object]";
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => helper(item, currentDepth + 1));
+        }
+        const result = {};
+        for (const key of Object.keys(obj)) {
+            result[key] = helper(obj[key], currentDepth + 1);
+        }
+        return result;
+    }
+    return JSON.stringify(helper(obj, 0), null, 2);
+}
 /**
  * Base class for all types of messages in a conversation. It includes
  * properties like `content`, `name`, and `additional_kwargs`. It also
@@ -129,6 +153,32 @@ class BaseMessage extends serializable_js_1.Serializable {
                 .kwargs,
         };
     }
+    static lc_name() {
+        return "BaseMessage";
+    }
+    // Can't be protected for silly reasons
+    get _printableFields() {
+        return {
+            id: this.id,
+            content: this.content,
+            name: this.name,
+            additional_kwargs: this.additional_kwargs,
+            response_metadata: this.response_metadata,
+        };
+    }
+    get [Symbol.toStringTag]() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this.constructor.lc_name();
+    }
+    // Override the default behavior of console.log
+    [Symbol.for("nodejs.util.inspect.custom")](depth) {
+        if (depth === null) {
+            return this;
+        }
+        const printable = stringifyWithDepthLimit(this._printableFields, Math.max(4, depth));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return `${this.constructor.lc_name()} ${printable}`;
+    }
 }
 exports.BaseMessage = BaseMessage;
 function isOpenAIToolCallArray(value) {

package/dist/messages/base.d.ts

@@ -23,7 +23,7 @@ export interface StoredMessageV1 {
     role: string | undefined;
     text: string;
 }
-export type MessageType = "human" | "ai" | "generic" | "system" | "function" | "tool";
+export type MessageType = "human" | "ai" | "generic" | "system" | "function" | "tool" | "remove";
 export type ImageDetail = "auto" | "low" | "high";
 export type MessageContentText = {
     type: "text";
@@ -123,6 +123,9 @@ export declare abstract class BaseMessage extends Serializable implements BaseMe
     /** @deprecated */
     kwargs?: Record<string, unknown>);
     toDict(): StoredMessage;
+    static lc_name(): string;
+    get _printableFields(): Record<string, unknown>;
+    get [Symbol.toStringTag](): any;
 }
 export type OpenAIToolCall = ToolCall & {
     index: number;

package/dist/messages/base.js

@@ -21,6 +21,30 @@ export function mergeContent(firstContent, secondContent) {
         return [...firstContent, { type: "text", text: secondContent }];
     }
 }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function stringifyWithDepthLimit(obj, depthLimit) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function helper(obj, currentDepth) {
+        if (typeof obj !== "object" || obj === null || obj === undefined) {
+            return obj;
+        }
+        if (currentDepth >= depthLimit) {
+            if (Array.isArray(obj)) {
+                return "[Array]";
+            }
+            return "[Object]";
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => helper(item, currentDepth + 1));
+        }
+        const result = {};
+        for (const key of Object.keys(obj)) {
+            result[key] = helper(obj[key], currentDepth + 1);
+        }
+        return result;
+    }
+    return JSON.stringify(helper(obj, 0), null, 2);
+}
 /**
  * Base class for all types of messages in a conversation. It includes
  * properties like `content`, `name`, and `additional_kwargs`. It also
@@ -125,6 +149,32 @@ export class BaseMessage extends Serializable {
                 .kwargs,
         };
     }
+    static lc_name() {
+        return "BaseMessage";
+    }
+    // Can't be protected for silly reasons
+    get _printableFields() {
+        return {
+            id: this.id,
+            content: this.content,
+            name: this.name,
+            additional_kwargs: this.additional_kwargs,
+            response_metadata: this.response_metadata,
+        };
+    }
+    get [Symbol.toStringTag]() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this.constructor.lc_name();
+    }
+    // Override the default behavior of console.log
+    [Symbol.for("nodejs.util.inspect.custom")](depth) {
+        if (depth === null) {
+            return this;
+        }
+        const printable = stringifyWithDepthLimit(this._printableFields, Math.max(4, depth));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return `${this.constructor.lc_name()} ${printable}`;
+    }
 }
 export function isOpenAIToolCallArray(value) {
     return (Array.isArray(value) &&

package/dist/messages/chat.cjs

@@ -32,6 +32,12 @@ class ChatMessage extends base_js_1.BaseMessage {
     static isInstance(message) {
         return message._getType() === "generic";
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            role: this.role,
+        };
+    }
 }
 exports.ChatMessage = ChatMessage;
 /**
@@ -68,5 +74,11 @@ class ChatMessageChunk extends base_js_1.BaseMessageChunk {
             id: this.id ?? chunk.id,
         });
     }
+    get _printableFields() {
+        return {
+            ...super._printableFields,
+            role: this.role,
+        };
+    }
 }
 exports.ChatMessageChunk = ChatMessageChunk;

package/dist/messages/chat.d.ts

@@ -13,6 +13,7 @@ export declare class ChatMessage extends BaseMessage implements ChatMessageField
     constructor(fields: ChatMessageFieldsWithRole);
     _getType(): MessageType;
     static isInstance(message: BaseMessage): message is ChatMessage;
+    get _printableFields(): Record<string, unknown>;
 }
 /**
  * Represents a chunk of a chat message, which can be concatenated with
@@ -25,4 +26,5 @@ export declare class ChatMessageChunk extends BaseMessageChunk {
     constructor(fields: ChatMessageFieldsWithRole);
     _getType(): MessageType;
     concat(chunk: ChatMessageChunk): ChatMessageChunk;
+    get _printableFields(): Record<string, unknown>;
 }