@langchain/core 0.2.16 → 0.2.18-rc.0

package/dist/tools/index.js

@@ -4,23 +4,8 @@ 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`
- * property that can hold the output that caused the exception.
- */
-export class ToolInputParsingException extends Error {
-    constructor(message, output) {
-        super(message);
-        Object.defineProperty(this, "output", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.output = output;
-    }
-}
+import { _isToolCall, ToolInputParsingException } from "./utils.js";
+export { ToolInputParsingException };
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
  */
@@ -282,29 +267,23 @@ export class BaseToolkit {
         return this.tools;
     }
 }
-/**
- * Creates a new StructuredTool instance with the provided function, name, description, and schema.
- * @function
- * @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<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 {DynamicStructuredTool<RunInput, RunOutput>} A new StructuredTool instance.
- */
 export function tool(func, fields) {
-    const schema = fields.schema ??
-        z.object({ input: z.string().optional() }).transform((obj) => obj.input);
-    const description = fields.description ?? schema.description ?? `${fields.name} tool`;
+    // If the schema is not provided, or it's a string schema, create a DynamicTool
+    if (!fields.schema || !("shape" in fields.schema) || !fields.schema.shape) {
+        return new DynamicTool({
+            name: fields.name,
+            description: fields.description ??
+                fields.schema?.description ??
+                `${fields.name} tool`,
+            responseFormat: fields.responseFormat,
+            func,
+        });
+    }
+    const description = fields.description ?? fields.schema.description ?? `${fields.name} tool`;
     return new DynamicStructuredTool({
         name: fields.name,
         description,
-        schema: schema,
+        schema: fields.schema,
         // TODO: Consider moving into DynamicStructuredTool constructor
         func: async (input, runManager, config) => {
             return new Promise((resolve, reject) => {
@@ -324,12 +303,6 @@ export function tool(func, fields) {
         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) {

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

@@ -72,3 +72,14 @@ test("Returns tool message if responseFormat is content_and_artifact and returns
     expect(toolResult.artifact).toEqual({ location: "San Francisco" });
     expect(toolResult.name).toBe("weather");
 });
+test("Tool can accept single string input", async () => {
+    const stringTool = tool((input) => {
+        return `${input}a`;
+    }, {
+        name: "string_tool",
+        description: "A tool that appends 'a' to the input string",
+        schema: z.string(),
+    });
+    const result = await stringTool.invoke("b");
+    expect(result).toBe("ba");
+});

package/dist/tools/utils.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolInputParsingException = exports._isToolCall = void 0;
+function _isToolCall(toolCall) {
+    return !!(toolCall &&
+        typeof toolCall === "object" &&
+        "type" in toolCall &&
+        toolCall.type === "tool_call");
+}
+exports._isToolCall = _isToolCall;
+/**
+ * Custom error class used to handle exceptions related to tool input parsing.
+ * It extends the built-in `Error` class and adds an optional `output`
+ * property that can hold the output that caused the exception.
+ */
+class ToolInputParsingException extends Error {
+    constructor(message, output) {
+        super(message);
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.output = output;
+    }
+}
+exports.ToolInputParsingException = ToolInputParsingException;

package/dist/tools/utils.d.ts

@@ -0,0 +1,11 @@
+import { ToolCall } from "../messages/tool.js";
+export declare function _isToolCall(toolCall?: unknown): toolCall is ToolCall;
+/**
+ * Custom error class used to handle exceptions related to tool input parsing.
+ * It extends the built-in `Error` class and adds an optional `output`
+ * property that can hold the output that caused the exception.
+ */
+export declare class ToolInputParsingException extends Error {
+    output?: string;
+    constructor(message: string, output?: string);
+}

package/dist/tools/utils.js

@@ -0,0 +1,23 @@
+export function _isToolCall(toolCall) {
+    return !!(toolCall &&
+        typeof toolCall === "object" &&
+        "type" in toolCall &&
+        toolCall.type === "tool_call");
+}
+/**
+ * Custom error class used to handle exceptions related to tool input parsing.
+ * It extends the built-in `Error` class and adds an optional `output`
+ * property that can hold the output that caused the exception.
+ */
+export class ToolInputParsingException extends Error {
+    constructor(message, output) {
+        super(message);
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.output = output;
+    }
+}

package/dist/tracers/base.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseTracer = void 0;
+exports.BaseTracer = exports.isBaseTracer = void 0;
 const base_js_1 = require("../callbacks/base.cjs");
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function _coerceToDict(value, defaultKey) {
@@ -15,6 +15,10 @@ function convertToDottedOrderFormat(epoch, runId, executionOrder) {
     const paddedOrder = executionOrder.toFixed(0).slice(0, 3).padStart(3, "0");
     return (stripNonAlphanumeric(`${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`) + runId);
 }
+function isBaseTracer(x) {
+    return typeof x._addRunToRunMap === "function";
+}
+exports.isBaseTracer = isBaseTracer;
 class BaseTracer extends base_js_1.BaseCallbackHandler {
     constructor(_fields) {
         super(...arguments);
@@ -41,7 +45,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
     _addChildRun(parentRun, childRun) {
         parentRun.child_runs.push(childRun);
     }
-    async _startTrace(run) {
+    _addRunToRunMap(run) {
         const currentDottedOrder = convertToDottedOrderFormat(run.start_time, run.id, run.execution_order);
         const storedRun = { ...run };
         if (storedRun.parent_run_id !== undefined) {
@@ -73,7 +77,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             storedRun.dotted_order = currentDottedOrder;
         }
         this.runMap.set(storedRun.id, storedRun);
-        await this.onRunCreate?.(storedRun);
+        return storedRun;
     }
     async _endTrace(run) {
         const parentRun = run.parent_run_id !== undefined && this.runMap.get(run.parent_run_id);
@@ -94,7 +98,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         }
         return parentRun.child_execution_order + 1;
     }
-    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
+    /**
+     * Create and add a run to the run map for LLM start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const finalExtraParams = metadata
@@ -120,11 +129,21 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: finalExtraParams ?? {},
             tags: tags || [],
         };
-        await this._startTrace(run);
+        return this._addRunToRunMap(run);
+    }
+    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
+        const run = this.runMap.get(runId) ??
+            this._createRunForLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name);
+        await this.onRunCreate?.(run);
         await this.onLLMStart?.(run);
         return run;
     }
-    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
+    /**
+     * Create and add a run to the run map for chat model start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const finalExtraParams = metadata
@@ -150,7 +169,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: finalExtraParams ?? {},
             tags: tags || [],
         };
-        await this._startTrace(run);
+        return this._addRunToRunMap(run);
+    }
+    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
+        const run = this.runMap.get(runId) ??
+            this._createRunForChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name);
+        await this.onRunCreate?.(run);
         await this.onLLMStart?.(run);
         return run;
     }
@@ -184,7 +208,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         await this._endTrace(run);
         return run;
     }
-    async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
+    /**
+     * Create and add a run to the run map for chain start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const run = {
@@ -207,7 +236,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: metadata ? { metadata } : {},
             tags: tags || [],
         };
-        await this._startTrace(run);
+        return this._addRunToRunMap(run);
+    }
+    async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
+        const run = this.runMap.get(runId) ??
+            this._createRunForChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name);
+        await this.onRunCreate?.(run);
         await this.onChainStart?.(run);
         return run;
     }
@@ -247,7 +281,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         await this._endTrace(run);
         return run;
     }
-    async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
+    /**
+     * Create and add a run to the run map for tool start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const run = {
@@ -270,7 +309,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: metadata ? { metadata } : {},
             tags: tags || [],
         };
-        await this._startTrace(run);
+        return this._addRunToRunMap(run);
+    }
+    async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
+        const run = this.runMap.get(runId) ??
+            this._createRunForToolStart(tool, input, runId, parentRunId, tags, metadata, name);
+        await this.onRunCreate?.(run);
         await this.onToolStart?.(run);
         return run;
     }
@@ -332,7 +376,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         });
         await this.onAgentEnd?.(run);
     }
-    async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
+    /**
+     * Create and add a run to the run map for retriever start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const run = {
@@ -355,7 +404,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: metadata ? { metadata } : {},
             tags: tags || [],
         };
-        await this._startTrace(run);
+        return this._addRunToRunMap(run);
+    }
+    async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
+        const run = this.runMap.get(runId) ??
+            this._createRunForRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name);
+        await this.onRunCreate?.(run);
         await this.onRetrieverStart?.(run);
         return run;
     }

package/dist/tracers/base.d.ts

@@ -24,6 +24,7 @@ export interface Run extends BaseRun {
 export interface AgentRun extends Run {
     actions: AgentAction[];
 }
+export declare function isBaseTracer(x: BaseCallbackHandler): x is BaseTracer;
 export declare abstract class BaseTracer extends BaseCallbackHandler {
     protected runMap: Map<string, Run>;
     constructor(_fields?: BaseCallbackHandlerInput);
@@ -31,13 +32,127 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
     protected stringifyError(error: unknown): string;
     protected abstract persistRun(run: Run): Promise<void>;
     protected _addChildRun(parentRun: Run, childRun: Run): void;
-    protected _startTrace(run: Run): Promise<void>;
+    _addRunToRunMap(run: Run): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+    };
     protected _endTrace(run: Run): Promise<void>;
     protected _getExecutionOrder(parentRunId: string | undefined): number;
+    /**
+     * Create and add a run to the run map for LLM start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+    };
     handleLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
+    /**
+     * Create and add a run to the run map for chat model start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+    };
     handleChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
     handleLLMEnd(output: LLMResult, runId: string): Promise<Run>;
     handleLLMError(error: unknown, runId: string): Promise<Run>;
+    /**
+     * Create and add a run to the run map for chain start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+    };
     handleChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string, name?: string): Promise<Run>;
     handleChainEnd(outputs: ChainValues, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {
         inputs?: Record<string, unknown>;
@@ -45,11 +160,71 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
     handleChainError(error: unknown, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {
         inputs?: Record<string, unknown>;
     }): Promise<Run>;
+    /**
+     * Create and add a run to the run map for tool start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+    };
     handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: 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>;
+    /**
+     * Create and add a run to the run map for retriever start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+    };
     handleRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
     handleRetrieverEnd(documents: Document<Record<string, unknown>>[], runId: string): Promise<Run>;
     handleRetrieverError(error: unknown, runId: string): Promise<Run>;