@langchain/core 0.2.15 → 0.2.16

package/dist/{tools.js → tools/index.js}

@@ -1,7 +1,9 @@
 import { z } from "zod";
-import { CallbackManager, parseCallbackConfigArg, } from "./callbacks/manager.js";
-import { BaseLangChain, } from "./language_models/base.js";
-import { ensureConfig } from "./runnables/config.js";
+import { CallbackManager, parseCallbackConfigArg, } from "../callbacks/manager.js";
+import { BaseLangChain, } from "../language_models/base.js";
+import { ensureConfig, patchConfig, } from "../runnables/config.js";
+import { ToolMessage } from "../messages/tool.js";
+import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
 /**
  * Custom error class used to handle exceptions related to tool input parsing.
  * It extends the built-in `Error` class and adds an optional `output`
@@ -34,6 +36,22 @@ export class StructuredTool extends BaseLangChain {
             writable: true,
             value: false
         });
+        /**
+         * The tool response format.
+         *
+         * If "content" then the output of the tool is interpreted as the contents of a
+         * ToolMessage. If "content_and_artifact" then the output is expected to be a
+         * two-tuple corresponding to the (content, artifact) of a ToolMessage.
+         *
+         * @default "content"
+         */
+        Object.defineProperty(this, "responseFormat", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "content"
+        });
+        this.responseFormat = fields?.responseFormat ?? this.responseFormat;
     }
     /**
      * Invokes the tool with the provided input and configuration.
@@ -42,7 +60,23 @@ export class StructuredTool extends BaseLangChain {
      * @returns A Promise that resolves with a string.
      */
     async invoke(input, config) {
-        return this.call(input, ensureConfig(config));
+        let tool_call_id;
+        let toolInput;
+        if (_isToolCall(input)) {
+            tool_call_id = input.id;
+            toolInput = input.args;
+        }
+        else {
+            toolInput = input;
+        }
+        const ensuredConfig = ensureConfig(config);
+        return this.call(toolInput, {
+            ...ensuredConfig,
+            configurable: {
+                ...ensuredConfig.configurable,
+                tool_call_id,
+            },
+        });
     }
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
@@ -77,8 +111,32 @@ export class StructuredTool extends BaseLangChain {
             await runManager?.handleToolError(e);
             throw e;
         }
-        await runManager?.handleToolEnd(result);
-        return result;
+        let content;
+        let artifact;
+        if (this.responseFormat === "content_and_artifact") {
+            if (Array.isArray(result) && result.length === 2) {
+                [content, artifact] = result;
+            }
+            else {
+                throw new Error(`Tool response format is "content_and_artifact" but the output was not a two-tuple.\nResult: ${JSON.stringify(result)}`);
+            }
+        }
+        else {
+            content = result;
+        }
+        let toolCallId;
+        if (config && "configurable" in config) {
+            toolCallId = config.configurable
+                .tool_call_id;
+        }
+        const formattedOutput = _formatToolOutput({
+            content,
+            artifact,
+            toolCallId,
+            name: this.name,
+        });
+        await runManager?.handleToolEnd(formattedOutput);
+        return formattedOutput;
     }
 }
 /**
@@ -152,8 +210,8 @@ export class DynamicTool extends Tool {
         return super.call(arg, config);
     }
     /** @ignore */
-    async _call(input, runManager, config) {
-        return this.func(input, runManager, config);
+    async _call(input, runManager, parentConfig) {
+        return this.func(input, runManager, parentConfig);
     }
 }
 /**
@@ -210,8 +268,8 @@ export class DynamicStructuredTool extends StructuredTool {
         }
         return super.call(arg, config, tags);
     }
-    _call(arg, runManager, config) {
-        return this.func(arg, runManager, config);
+    _call(arg, runManager, parentConfig) {
+        return this.func(arg, runManager, parentConfig);
     }
 }
 /**
@@ -227,15 +285,17 @@ export class BaseToolkit {
 /**
  * Creates a new StructuredTool instance with the provided function, name, description, and schema.
  * @function
- * @template {ZodAny} RunInput The input schema for the tool.
+ * @template {RunInput extends ZodAny = ZodAny} RunInput The input schema for the tool. This corresponds to the input type when the tool is invoked.
+ * @template {RunOutput = any} RunOutput The output type for the tool. This corresponds to the output type when the tool is invoked.
+ * @template {FuncInput extends z.infer<RunInput> | ToolCall = z.infer<RunInput>} FuncInput The input type for the function.
  *
- * @param {RunnableFunc<RunInput, string>} func - The function to invoke when the tool is called.
+ * @param {RunnableFunc<z.infer<RunInput> | ToolCall, RunOutput>} func - The function to invoke when the tool is called.
  * @param fields - An object containing the following properties:
  * @param {string} fields.name The name of the tool.
  * @param {string | undefined} fields.description The description of the tool. Defaults to either the description on the Zod schema, or `${fields.name} tool`.
  * @param {z.ZodObject<any, any, any, any>} fields.schema The Zod schema defining the input for the tool.
  *
- * @returns {StructuredTool<RunInput, string>} A new StructuredTool instance.
+ * @returns {DynamicStructuredTool<RunInput, RunOutput>} A new StructuredTool instance.
  */
 export function tool(func, fields) {
     const schema = fields.schema ??
@@ -245,6 +305,62 @@ export function tool(func, fields) {
         name: fields.name,
         description,
         schema: schema,
-        func: async (input, _runManager, config) => func(input, config),
+        // TODO: Consider moving into DynamicStructuredTool constructor
+        func: async (input, runManager, config) => {
+            return new Promise((resolve, reject) => {
+                const childConfig = patchConfig(config, {
+                    callbacks: runManager?.getChild(),
+                });
+                void AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
+                    try {
+                        resolve(func(input, childConfig));
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                });
+            });
+        },
+        responseFormat: fields.responseFormat,
     });
 }
+function _isToolCall(toolCall) {
+    return !!(toolCall &&
+        typeof toolCall === "object" &&
+        "type" in toolCall &&
+        toolCall.type === "tool_call");
+}
+function _formatToolOutput(params) {
+    const { content, artifact, toolCallId } = params;
+    if (toolCallId) {
+        if (typeof content === "string" ||
+            (Array.isArray(content) &&
+                content.every((item) => typeof item === "object"))) {
+            return new ToolMessage({
+                content,
+                artifact,
+                tool_call_id: toolCallId,
+                name: params.name,
+            });
+        }
+        else {
+            return new ToolMessage({
+                content: _stringify(content),
+                artifact,
+                tool_call_id: toolCallId,
+                name: params.name,
+            });
+        }
+    }
+    else {
+        return content;
+    }
+}
+function _stringify(content) {
+    try {
+        return JSON.stringify(content, null, 2);
+    }
+    catch (_noOp) {
+        return `${content}`;
+    }
+}

package/dist/tools/tests/tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/tests/tools.test.js

@@ -0,0 +1,74 @@
+import { test, expect } from "@jest/globals";
+import { z } from "zod";
+import { tool } from "../index.js";
+import { ToolMessage } from "../../messages/tool.js";
+test("Tool should error if responseFormat is content_and_artifact but the function doesn't return a tuple", async () => {
+    const weatherSchema = z.object({
+        location: z.string(),
+    });
+    const weatherTool = tool((_) => {
+        return "str";
+    }, {
+        name: "weather",
+        schema: weatherSchema,
+        responseFormat: "content_and_artifact",
+    });
+    await expect(async () => {
+        await weatherTool.invoke({ location: "San Francisco" });
+    }).rejects.toThrow();
+});
+test("Tool works if responseFormat is content_and_artifact and returns a tuple", async () => {
+    const weatherSchema = z.object({
+        location: z.string(),
+    });
+    const weatherTool = tool((input) => {
+        return ["msg_content", input];
+    }, {
+        name: "weather",
+        schema: weatherSchema,
+        responseFormat: "content_and_artifact",
+    });
+    const toolResult = await weatherTool.invoke({ location: "San Francisco" });
+    expect(toolResult).not.toBeInstanceOf(ToolMessage);
+    expect(toolResult).toBe("msg_content");
+});
+test("Does not return tool message if responseFormat is content_and_artifact and returns a tuple and a tool call with no id is passed in", async () => {
+    const weatherSchema = z.object({
+        location: z.string(),
+    });
+    const weatherTool = tool((input) => {
+        return ["msg_content", input];
+    }, {
+        name: "weather",
+        schema: weatherSchema,
+        responseFormat: "content_and_artifact",
+    });
+    const toolResult = await weatherTool.invoke({
+        args: { location: "San Francisco" },
+        name: "weather",
+        type: "tool_call",
+    });
+    expect(toolResult).toBe("msg_content");
+});
+test("Returns tool message if responseFormat is content_and_artifact and returns a tuple and a tool call with id is passed in", async () => {
+    const weatherSchema = z.object({
+        location: z.string(),
+    });
+    const weatherTool = tool((input) => {
+        return ["msg_content", input];
+    }, {
+        name: "weather",
+        schema: weatherSchema,
+        responseFormat: "content_and_artifact",
+    });
+    const toolResult = await weatherTool.invoke({
+        id: "testid",
+        args: { location: "San Francisco" },
+        name: "weather",
+        type: "tool_call",
+    });
+    expect(toolResult).toBeInstanceOf(ToolMessage);
+    expect(toolResult.content).toBe("msg_content");
+    expect(toolResult.artifact).toEqual({ location: "San Francisco" });
+    expect(toolResult.name).toBe("weather");
+});

package/dist/tracers/base.cjs

@@ -274,6 +274,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         await this.onToolStart?.(run);
         return run;
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async handleToolEnd(output, runId) {
         const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "tool") {

package/dist/tracers/base.d.ts

@@ -46,7 +46,7 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
         inputs?: Record<string, unknown>;
     }): Promise<Run>;
     handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
-    handleToolEnd(output: string, runId: string): Promise<Run>;
+    handleToolEnd(output: any, runId: string): Promise<Run>;
     handleToolError(error: unknown, runId: string): Promise<Run>;
     handleAgentAction(action: AgentAction, runId: string): Promise<void>;
     handleAgentEnd(action: AgentFinish, runId: string): Promise<void>;

package/dist/tracers/base.js

@@ -271,6 +271,7 @@ export class BaseTracer extends BaseCallbackHandler {
         await this.onToolStart?.(run);
         return run;
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async handleToolEnd(output, runId) {
         const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "tool") {

package/dist/tracers/event_stream.cjs

@@ -489,6 +489,21 @@ class EventStreamCallbackHandler extends base_js_1.BaseTracer {
             metadata: runInfo.metadata,
         }, runInfo);
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async handleCustomEvent(eventName, data, runId) {
+        const runInfo = this.runInfoMap.get(runId);
+        if (runInfo === undefined) {
+            throw new Error(`handleCustomEvent: Run ID ${runId} not found in run map.`);
+        }
+        await this.send({
+            event: "on_custom_event",
+            run_id: runId,
+            name: eventName,
+            tags: runInfo.tags,
+            metadata: runInfo.metadata,
+            data,
+        }, runInfo);
+    }
     async finish() {
         const pendingPromises = [...this.tappedPromises.values()];
         void Promise.all(pendingPromises).finally(() => {

package/dist/tracers/event_stream.d.ts

@@ -133,6 +133,7 @@ export declare class EventStreamCallbackHandler extends BaseTracer {
     onToolEnd(run: Run): Promise<void>;
     onRetrieverStart(run: Run): Promise<void>;
     onRetrieverEnd(run: Run): Promise<void>;
+    handleCustomEvent(eventName: string, data: any, runId: string): Promise<void>;
     finish(): Promise<void>;
 }
 export {};

package/dist/tracers/event_stream.js

@@ -485,6 +485,21 @@ export class EventStreamCallbackHandler extends BaseTracer {
             metadata: runInfo.metadata,
         }, runInfo);
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async handleCustomEvent(eventName, data, runId) {
+        const runInfo = this.runInfoMap.get(runId);
+        if (runInfo === undefined) {
+            throw new Error(`handleCustomEvent: Run ID ${runId} not found in run map.`);
+        }
+        await this.send({
+            event: "on_custom_event",
+            run_id: runId,
+            name: eventName,
+            tags: runInfo.tags,
+            metadata: runInfo.metadata,
+            data,
+        }, runInfo);
+    }
     async finish() {
         const pendingPromises = [...this.tappedPromises.values()];
         void Promise.all(pendingPromises).finally(() => {

package/dist/types/zod.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/zod.d.ts

@@ -0,0 +1,2 @@
+import type { z } from "zod";
+export type ZodAny = z.ZodObject<any, any, any, any>;

package/dist/types/zod.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/function_calling.cjs

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStructuredTool = exports.convertToOpenAITool = exports.convertToOpenAIFunction = void 0;
+exports.isRunnableToolLike = exports.isStructuredTool = exports.convertToOpenAITool = exports.convertToOpenAIFunction = void 0;
 const zod_to_json_schema_1 = require("zod-to-json-schema");
+const base_js_1 = require("../runnables/base.cjs");
 /**
- * Formats a `StructuredTool` instance into a format that is compatible
- * with OpenAI function calling. It uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` into a JSON
- * schema, which is then used as the parameters for the OpenAI function.
+ * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
+ * that is compatible with OpenAI function calling. It uses the `zodToJsonSchema`
+ * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
+ * into a JSON schema, which is then used as the parameters for the OpenAI function.
+ *
+ * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
+ * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
  */
 function convertToOpenAIFunction(tool) {
     return {
@@ -17,15 +21,19 @@ function convertToOpenAIFunction(tool) {
 }
 exports.convertToOpenAIFunction = convertToOpenAIFunction;
 /**
- * Formats a `StructuredTool` instance into a format that is compatible
- * with OpenAI tool calling. It uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` into a JSON
- * schema, which is then used as the parameters for the OpenAI tool.
+ * Formats a `StructuredTool` or `RunnableToolLike` instance into a
+ * format that is compatible with OpenAI tool calling. It uses the
+ * `zodToJsonSchema` function to convert the schema of the `StructuredTool`
+ * or `RunnableToolLike` into a JSON schema, which is then used as the
+ * parameters for the OpenAI tool.
+ *
+ * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
+ * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
  */
 function convertToOpenAITool(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 tool) {
-    if (isStructuredTool(tool)) {
+    if (isStructuredTool(tool) || isRunnableToolLike(tool)) {
         return {
             type: "function",
             function: convertToOpenAIFunction(tool),
@@ -34,6 +42,12 @@ tool) {
     return tool;
 }
 exports.convertToOpenAITool = convertToOpenAITool;
+/**
+ * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
+ *
+ * @param {StructuredToolInterface | Record<string, any> | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.
+ * @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.
+ */
 function isStructuredTool(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 tool) {
@@ -41,3 +55,17 @@ tool) {
         Array.isArray(tool.lc_namespace));
 }
 exports.isStructuredTool = isStructuredTool;
+/**
+ * Confirm whether the inputted tool is an instance of `RunnableToolLike`.
+ *
+ * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.
+ * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.
+ */
+function isRunnableToolLike(tool) {
+    return (tool !== undefined &&
+        base_js_1.Runnable.isRunnable(tool) &&
+        "lc_name" in tool.constructor &&
+        typeof tool.constructor.lc_name === "function" &&
+        tool.constructor.lc_name() === "RunnableToolLike");
+}
+exports.isRunnableToolLike = isRunnableToolLike;

package/dist/utils/function_calling.d.ts

@@ -1,17 +1,38 @@
-import { StructuredToolInterface } from "../tools.js";
+import { StructuredToolInterface } from "../tools/index.js";
 import { FunctionDefinition, ToolDefinition } from "../language_models/base.js";
+import { RunnableToolLike } from "../runnables/base.js";
 /**
- * Formats a `StructuredTool` instance into a format that is compatible
- * with OpenAI function calling. It uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` into a JSON
- * schema, which is then used as the parameters for the OpenAI function.
+ * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
+ * that is compatible with OpenAI function calling. It uses the `zodToJsonSchema`
+ * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
+ * into a JSON schema, which is then used as the parameters for the OpenAI function.
+ *
+ * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
+ * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
  */
-export declare function convertToOpenAIFunction(tool: StructuredToolInterface): FunctionDefinition;
+export declare function convertToOpenAIFunction(tool: StructuredToolInterface | RunnableToolLike): FunctionDefinition;
 /**
- * Formats a `StructuredTool` instance into a format that is compatible
- * with OpenAI tool calling. It uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` into a JSON
- * schema, which is then used as the parameters for the OpenAI tool.
+ * Formats a `StructuredTool` or `RunnableToolLike` instance into a
+ * format that is compatible with OpenAI tool calling. It uses the
+ * `zodToJsonSchema` function to convert the schema of the `StructuredTool`
+ * or `RunnableToolLike` into a JSON schema, which is then used as the
+ * parameters for the OpenAI tool.
+ *
+ * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
+ * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
+ */
+export declare function convertToOpenAITool(tool: StructuredToolInterface | Record<string, any> | RunnableToolLike): ToolDefinition;
+/**
+ * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
+ *
+ * @param {StructuredToolInterface | Record<string, any> | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.
+ * @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.
  */
-export declare function convertToOpenAITool(tool: StructuredToolInterface | Record<string, any>): ToolDefinition;
 export declare function isStructuredTool(tool?: StructuredToolInterface | Record<string, any>): tool is StructuredToolInterface;
+/**
+ * Confirm whether the inputted tool is an instance of `RunnableToolLike`.
+ *
+ * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.
+ * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.
+ */
+export declare function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike;

package/dist/utils/function_calling.js

@@ -1,9 +1,13 @@
 import { zodToJsonSchema } from "zod-to-json-schema";
+import { Runnable } from "../runnables/base.js";
 /**
- * Formats a `StructuredTool` instance into a format that is compatible
- * with OpenAI function calling. It uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` into a JSON
- * schema, which is then used as the parameters for the OpenAI function.
+ * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
+ * that is compatible with OpenAI function calling. It uses the `zodToJsonSchema`
+ * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
+ * into a JSON schema, which is then used as the parameters for the OpenAI function.
+ *
+ * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
+ * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
  */
 export function convertToOpenAIFunction(tool) {
     return {
@@ -13,15 +17,19 @@ export function convertToOpenAIFunction(tool) {
     };
 }
 /**
- * Formats a `StructuredTool` instance into a format that is compatible
- * with OpenAI tool calling. It uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` into a JSON
- * schema, which is then used as the parameters for the OpenAI tool.
+ * Formats a `StructuredTool` or `RunnableToolLike` instance into a
+ * format that is compatible with OpenAI tool calling. It uses the
+ * `zodToJsonSchema` function to convert the schema of the `StructuredTool`
+ * or `RunnableToolLike` into a JSON schema, which is then used as the
+ * parameters for the OpenAI tool.
+ *
+ * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
+ * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
  */
 export function convertToOpenAITool(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 tool) {
-    if (isStructuredTool(tool)) {
+    if (isStructuredTool(tool) || isRunnableToolLike(tool)) {
         return {
             type: "function",
             function: convertToOpenAIFunction(tool),
@@ -29,9 +37,28 @@ tool) {
     }
     return tool;
 }
+/**
+ * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
+ *
+ * @param {StructuredToolInterface | Record<string, any> | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.
+ * @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.
+ */
 export function isStructuredTool(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 tool) {
     return (tool !== undefined &&
         Array.isArray(tool.lc_namespace));
 }
+/**
+ * Confirm whether the inputted tool is an instance of `RunnableToolLike`.
+ *
+ * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.
+ * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.
+ */
+export function isRunnableToolLike(tool) {
+    return (tool !== undefined &&
+        Runnable.isRunnable(tool) &&
+        "lc_name" in tool.constructor &&
+        typeof tool.constructor.lc_name === "function" &&
+        tool.constructor.lc_name() === "RunnableToolLike");
+}

package/dist/utils/testing/index.cjs

@@ -13,7 +13,7 @@ const base_js_1 = require("../../output_parsers/base.cjs");
 const outputs_js_1 = require("../../outputs.cjs");
 const index_js_2 = require("../../retrievers/index.cjs");
 const base_js_2 = require("../../runnables/base.cjs");
-const tools_js_1 = require("../../tools.cjs");
+const index_js_3 = require("../../tools/index.cjs");
 const base_js_3 = require("../../tracers/base.cjs");
 const embeddings_js_1 = require("../../embeddings.cjs");
 /**
@@ -162,7 +162,14 @@ class FakeChatModel extends chat_models_js_1.BaseChatModel {
                 ],
             };
         }
-        const text = messages.map((m) => m.content).join("\n");
+        const text = messages
+            .map((m) => {
+            if (typeof m.content === "string") {
+                return m.content;
+            }
+            return JSON.stringify(m.content, null, 2);
+        })
+            .join("\n");
         await runManager?.handleLLMNewToken(text);
         return {
             generations: [
@@ -475,7 +482,7 @@ class FakeTracer extends base_js_3.BaseTracer {
     }
 }
 exports.FakeTracer = FakeTracer;
-class FakeTool extends tools_js_1.StructuredTool {
+class FakeTool extends index_js_3.StructuredTool {
     constructor(fields) {
         super(fields);
         Object.defineProperty(this, "name", {

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

@@ -9,7 +9,7 @@ import { BaseOutputParser } from "../../output_parsers/base.js";
 import { GenerationChunk, type ChatResult, ChatGenerationChunk } from "../../outputs.js";
 import { BaseRetriever } from "../../retrievers/index.js";
 import { Runnable } from "../../runnables/base.js";
-import { StructuredTool, ToolParams } from "../../tools.js";
+import { StructuredTool, ToolParams } from "../../tools/index.js";
 import { BaseTracer, Run } from "../../tracers/base.js";
 import { Embeddings, EmbeddingsParams } from "../../embeddings.js";
 import { StructuredOutputMethodParams, BaseLanguageModelInput, StructuredOutputMethodOptions } from "../../language_models/base.js";

package/dist/utils/testing/index.js

@@ -10,7 +10,7 @@ import { BaseOutputParser } from "../../output_parsers/base.js";
 import { ChatGenerationChunk, } from "../../outputs.js";
 import { BaseRetriever } from "../../retrievers/index.js";
 import { Runnable, RunnableLambda } from "../../runnables/base.js";
-import { StructuredTool } from "../../tools.js";
+import { StructuredTool } from "../../tools/index.js";
 import { BaseTracer } from "../../tracers/base.js";
 import { Embeddings } from "../../embeddings.js";
 /**
@@ -155,7 +155,14 @@ export class FakeChatModel extends BaseChatModel {
                 ],
             };
         }
-        const text = messages.map((m) => m.content).join("\n");
+        const text = messages
+            .map((m) => {
+            if (typeof m.content === "string") {
+                return m.content;
+            }
+            return JSON.stringify(m.content, null, 2);
+        })
+            .join("\n");
         await runManager?.handleLLMNewToken(text);
         return {
             generations: [