@langchain/core 0.2.17 → 0.2.18

package/dist/tracers/tests/langsmith_interop.test.js

@@ -0,0 +1,551 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-process-env */
+/* eslint-disable no-promise-executor-return */
+import { jest } from "@jest/globals";
+import { traceable } from "langsmith/traceable";
+import { RunnableLambda } from "../../runnables/base.js";
+import { HumanMessage } from "../../messages/index.js";
+let fetchMock;
+const originalTracingEnvValue = process.env.LANGCHAIN_TRACING_V2;
+beforeEach(() => {
+    fetchMock = jest
+        .spyOn(global, "fetch")
+        .mockImplementation(() => Promise.resolve({ ok: true, text: () => "" }));
+    process.env.LANGCHAIN_TRACING_V2 = "true";
+});
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+afterAll(() => {
+    process.env.LANGCHAIN_TRACING_V2 = originalTracingEnvValue;
+});
+test.each(["true", "false"])("traceables nested within runnables with background callbacks %s", async (value) => {
+    process.env.LANGCHAIN_CALLBACKS_BACKGROUND = value;
+    const aiGreet = traceable(async (msg, name = "world") => {
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        return msg.content + name;
+    }, { name: "aiGreet", tracingEnabled: true });
+    const root = RunnableLambda.from(async (messages) => {
+        const lastMsg = messages.at(-1);
+        const greetOne = await aiGreet(lastMsg, "David");
+        return [greetOne];
+    });
+    await root.invoke([new HumanMessage({ content: "Hello!" })]);
+    const relevantCalls = fetchMock.mock.calls.filter((call) => {
+        return call[0].startsWith("https://api.smith.langchain.com/runs");
+    });
+    expect(relevantCalls.length).toEqual(4);
+    const firstCallParams = JSON.parse(relevantCalls[0][1].body);
+    const secondCallParams = JSON.parse(relevantCalls[1][1].body);
+    const thirdCallParams = JSON.parse(relevantCalls[2][1].body);
+    const fourthCallParams = JSON.parse(relevantCalls[3][1].body);
+    expect(firstCallParams).toMatchObject({
+        id: firstCallParams.id,
+        name: "RunnableLambda",
+        start_time: expect.any(Number),
+        serialized: {
+            lc: 1,
+            type: "not_implemented",
+            id: ["langchain_core", "runnables", "RunnableLambda"],
+        },
+        events: [{ name: "start", time: expect.any(String) }],
+        inputs: {
+            input: [
+                {
+                    lc: 1,
+                    type: "constructor",
+                    id: ["langchain_core", "messages", "HumanMessage"],
+                    kwargs: {
+                        content: "Hello!",
+                        additional_kwargs: {},
+                        response_metadata: {},
+                    },
+                },
+            ],
+        },
+        execution_order: 1,
+        child_execution_order: 1,
+        run_type: "chain",
+        extra: expect.any(Object),
+        tags: [],
+        trace_id: firstCallParams.id,
+        dotted_order: expect.any(String),
+    });
+    expect(secondCallParams).toMatchObject({
+        id: expect.any(String),
+        name: "aiGreet",
+        start_time: expect.any(Number),
+        run_type: "chain",
+        extra: expect.any(Object),
+        serialized: {},
+        inputs: {
+            args: [
+                {
+                    lc: 1,
+                    type: "constructor",
+                    id: ["langchain_core", "messages", "HumanMessage"],
+                    kwargs: {
+                        content: "Hello!",
+                        additional_kwargs: {},
+                        response_metadata: {},
+                    },
+                },
+                "David",
+            ],
+        },
+        child_runs: [],
+        parent_run_id: firstCallParams.id,
+        trace_id: firstCallParams.id,
+        dotted_order: expect.stringContaining(`${firstCallParams.dotted_order}.`),
+        tags: [],
+    });
+    expect(thirdCallParams).toMatchObject({
+        end_time: expect.any(Number),
+        inputs: {
+            args: [
+                {
+                    lc: 1,
+                    type: "constructor",
+                    id: ["langchain_core", "messages", "HumanMessage"],
+                    kwargs: {
+                        content: "Hello!",
+                        additional_kwargs: {},
+                        response_metadata: {},
+                    },
+                },
+                "David",
+            ],
+        },
+        outputs: { outputs: "Hello!David" },
+        parent_run_id: firstCallParams.id,
+        extra: expect.any(Object),
+        dotted_order: secondCallParams.dotted_order,
+        trace_id: firstCallParams.id,
+        tags: [],
+    });
+    expect(fourthCallParams).toMatchObject({
+        end_time: expect.any(Number),
+        outputs: { output: ["Hello!David"] },
+        events: [
+            { name: "start", time: expect.any(String) },
+            { name: "end", time: expect.any(String) },
+        ],
+        inputs: {
+            input: [
+                {
+                    lc: 1,
+                    type: "constructor",
+                    id: ["langchain_core", "messages", "HumanMessage"],
+                    kwargs: {
+                        content: "Hello!",
+                        additional_kwargs: {},
+                        response_metadata: {},
+                    },
+                },
+            ],
+        },
+        trace_id: firstCallParams.id,
+        dotted_order: firstCallParams.dotted_order,
+    });
+});
+test.each(["true", "false"])("streaming traceables nested within runnables with background callbacks %s", async (value) => {
+    process.env.LANGCHAIN_CALLBACKS_BACKGROUND = value;
+    const aiGreet = traceable(async function* (msg, name = "world") {
+        const res = msg.content + name;
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        for (const letter of res.split("")) {
+            yield letter;
+        }
+    }, { name: "aiGreet" });
+    const root = RunnableLambda.from(async function* (messages) {
+        const lastMsg = messages.at(-1);
+        yield* aiGreet(lastMsg, "David");
+    });
+    const stream = await root.stream([new HumanMessage({ content: "Hello!" })]);
+    for await (const _ of stream) {
+        // Just consume iterator
+    }
+    const relevantCalls = fetchMock.mock.calls.filter((call) => {
+        return call[0].startsWith("https://api.smith.langchain.com/runs");
+    });
+    expect(relevantCalls.length).toEqual(4);
+    const firstCallParams = JSON.parse(relevantCalls[0][1].body);
+    const secondCallParams = JSON.parse(relevantCalls[1][1].body);
+    const thirdCallParams = JSON.parse(relevantCalls[2][1].body);
+    const fourthCallParams = JSON.parse(relevantCalls[3][1].body);
+    expect(firstCallParams).toMatchObject({
+        id: firstCallParams.id,
+        name: "RunnableLambda",
+        start_time: expect.any(Number),
+        serialized: {
+            lc: 1,
+            type: "not_implemented",
+            id: ["langchain_core", "runnables", "RunnableLambda"],
+        },
+        events: [{ name: "start", time: expect.any(String) }],
+        inputs: {
+            input: "",
+        },
+        execution_order: 1,
+        child_execution_order: 1,
+        run_type: "chain",
+        extra: expect.any(Object),
+        tags: [],
+        trace_id: firstCallParams.id,
+        dotted_order: expect.any(String),
+    });
+    expect(secondCallParams).toMatchObject({
+        id: expect.any(String),
+        name: "aiGreet",
+        start_time: expect.any(Number),
+        run_type: "chain",
+        extra: expect.any(Object),
+        serialized: {},
+        inputs: {
+            args: [
+                {
+                    lc: 1,
+                    type: "constructor",
+                    id: ["langchain_core", "messages", "HumanMessage"],
+                    kwargs: {
+                        content: "Hello!",
+                        additional_kwargs: {},
+                        response_metadata: {},
+                    },
+                },
+                "David",
+            ],
+        },
+        child_runs: [],
+        parent_run_id: firstCallParams.id,
+        trace_id: firstCallParams.id,
+        dotted_order: expect.stringContaining(`${firstCallParams.dotted_order}.`),
+        tags: [],
+    });
+    expect(thirdCallParams).toMatchObject({
+        end_time: expect.any(Number),
+        inputs: {
+            args: [
+                {
+                    lc: 1,
+                    type: "constructor",
+                    id: ["langchain_core", "messages", "HumanMessage"],
+                    kwargs: {
+                        content: "Hello!",
+                        additional_kwargs: {},
+                        response_metadata: {},
+                    },
+                },
+                "David",
+            ],
+        },
+        outputs: {
+            outputs: ["H", "e", "l", "l", "o", "!", "D", "a", "v", "i", "d"],
+        },
+        parent_run_id: firstCallParams.id,
+        extra: expect.any(Object),
+        dotted_order: secondCallParams.dotted_order,
+        trace_id: firstCallParams.id,
+        tags: [],
+    });
+    expect(fourthCallParams).toMatchObject({
+        end_time: expect.any(Number),
+        outputs: { output: "Hello!David" },
+        events: [
+            { name: "start", time: expect.any(String) },
+            { name: "end", time: expect.any(String) },
+        ],
+        inputs: {
+            input: [
+                {
+                    lc: 1,
+                    type: "constructor",
+                    id: ["langchain_core", "messages", "HumanMessage"],
+                    kwargs: {
+                        content: "Hello!",
+                        additional_kwargs: {},
+                        response_metadata: {},
+                    },
+                },
+            ],
+        },
+        trace_id: firstCallParams.id,
+        dotted_order: firstCallParams.dotted_order,
+    });
+});
+test.each(["true", "false"])("runnables nested within traceables with background callbacks %s", async (value) => {
+    process.env.LANGCHAIN_CALLBACKS_BACKGROUND = value;
+    const nested = RunnableLambda.from(async (messages) => {
+        const lastMsg = messages.at(-1);
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        return [lastMsg.content];
+    });
+    const aiGreet = traceable(async (msg, name = "world") => {
+        const contents = await nested.invoke([msg]);
+        return contents[0] + name;
+    }, { name: "aiGreet", tracingEnabled: true });
+    await aiGreet(new HumanMessage({ content: "Hello!" }), "mitochondria");
+    const relevantCalls = fetchMock.mock.calls.filter((call) => {
+        return call[0].startsWith("https://api.smith.langchain.com/runs");
+    });
+    expect(relevantCalls.length).toEqual(4);
+    const firstCallParams = JSON.parse(relevantCalls[0][1].body);
+    const secondCallParams = JSON.parse(relevantCalls[1][1].body);
+    const thirdCallParams = JSON.parse(relevantCalls[2][1].body);
+    const fourthCallParams = JSON.parse(relevantCalls[3][1].body);
+    expect(firstCallParams).toMatchObject({
+        id: firstCallParams.id,
+        name: "aiGreet",
+        start_time: expect.any(Number),
+        run_type: "chain",
+        extra: expect.any(Object),
+        serialized: {},
+        inputs: {
+            args: [
+                {
+                    lc: 1,
+                    type: "constructor",
+                    id: ["langchain_core", "messages", "HumanMessage"],
+                    kwargs: {
+                        content: "Hello!",
+                        additional_kwargs: {},
+                        response_metadata: {},
+                    },
+                },
+                "mitochondria",
+            ],
+        },
+        child_runs: [],
+        trace_id: firstCallParams.id,
+        dotted_order: firstCallParams.dotted_order,
+        tags: [],
+    });
+    expect(secondCallParams).toMatchObject({
+        id: secondCallParams.id,
+        name: "RunnableLambda",
+        parent_run_id: firstCallParams.id,
+        start_time: expect.any(Number),
+        serialized: {
+            lc: 1,
+            type: "not_implemented",
+            id: ["langchain_core", "runnables", "RunnableLambda"],
+        },
+        events: [{ name: "start", time: expect.any(String) }],
+        inputs: {
+            input: [
+                {
+                    lc: 1,
+                    type: "constructor",
+                    id: ["langchain_core", "messages", "HumanMessage"],
+                    kwargs: {
+                        content: "Hello!",
+                        additional_kwargs: {},
+                        response_metadata: {},
+                    },
+                },
+            ],
+        },
+        execution_order: 2,
+        child_execution_order: 2,
+        run_type: "chain",
+        extra: expect.any(Object),
+        tags: [],
+        trace_id: firstCallParams.id,
+        dotted_order: expect.stringContaining(`${firstCallParams.dotted_order}.`),
+    });
+    expect(thirdCallParams).toMatchObject({
+        end_time: expect.any(Number),
+        outputs: { output: ["Hello!"] },
+        events: [
+            { name: "start", time: expect.any(String) },
+            { name: "end", time: expect.any(String) },
+        ],
+        inputs: {
+            input: [
+                {
+                    lc: 1,
+                    type: "constructor",
+                    id: ["langchain_core", "messages", "HumanMessage"],
+                    kwargs: {
+                        content: "Hello!",
+                        additional_kwargs: {},
+                        response_metadata: {},
+                    },
+                },
+            ],
+        },
+        trace_id: firstCallParams.id,
+        dotted_order: expect.stringContaining(`${firstCallParams.dotted_order}.`),
+        parent_run_id: firstCallParams.id,
+    });
+    expect(fourthCallParams).toMatchObject({
+        end_time: expect.any(Number),
+        inputs: {
+            args: [
+                {
+                    lc: 1,
+                    type: "constructor",
+                    id: ["langchain_core", "messages", "HumanMessage"],
+                    kwargs: {
+                        content: "Hello!",
+                        additional_kwargs: {},
+                        response_metadata: {},
+                    },
+                },
+                "mitochondria",
+            ],
+        },
+        outputs: { outputs: "Hello!mitochondria" },
+        extra: expect.any(Object),
+        dotted_order: firstCallParams.dotted_order,
+        trace_id: firstCallParams.id,
+        tags: [],
+    });
+});
+test.each(["true", "false"])("streaming runnables nested within traceables with background callbacks %s", async (value) => {
+    process.env.LANGCHAIN_CALLBACKS_BACKGROUND = value;
+    const nested = RunnableLambda.from(async function* (messages) {
+        const lastMsg = messages.at(-1);
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        for (const letter of lastMsg.content.split("")) {
+            yield letter;
+        }
+    });
+    const aiGreet = traceable(async function* (msg, name = "world") {
+        for await (const chunk of await nested.stream([msg])) {
+            yield chunk;
+        }
+        for (const letter of name.split("")) {
+            yield letter;
+        }
+    }, { name: "aiGreet", tracingEnabled: true });
+    for await (const _ of aiGreet(new HumanMessage({ content: "Hello!" }), "mitochondria")) {
+        // Just consume iterator
+    }
+    const relevantCalls = fetchMock.mock.calls.filter((call) => {
+        return call[0].startsWith("https://api.smith.langchain.com/runs");
+    });
+    expect(relevantCalls.length).toEqual(4);
+    const firstCallParams = JSON.parse(relevantCalls[0][1].body);
+    const secondCallParams = JSON.parse(relevantCalls[1][1].body);
+    const thirdCallParams = JSON.parse(relevantCalls[2][1].body);
+    const fourthCallParams = JSON.parse(relevantCalls[3][1].body);
+    expect(firstCallParams).toMatchObject({
+        id: firstCallParams.id,
+        name: "aiGreet",
+        start_time: expect.any(Number),
+        run_type: "chain",
+        extra: expect.any(Object),
+        serialized: {},
+        inputs: {
+            args: [
+                {
+                    lc: 1,
+                    type: "constructor",
+                    id: ["langchain_core", "messages", "HumanMessage"],
+                    kwargs: {
+                        content: "Hello!",
+                        additional_kwargs: {},
+                        response_metadata: {},
+                    },
+                },
+                "mitochondria",
+            ],
+        },
+        child_runs: [],
+        trace_id: firstCallParams.id,
+        dotted_order: firstCallParams.dotted_order,
+        tags: [],
+    });
+    expect(secondCallParams).toMatchObject({
+        id: secondCallParams.id,
+        name: "RunnableLambda",
+        parent_run_id: firstCallParams.id,
+        start_time: expect.any(Number),
+        serialized: {
+            lc: 1,
+            type: "not_implemented",
+            id: ["langchain_core", "runnables", "RunnableLambda"],
+        },
+        events: [{ name: "start", time: expect.any(String) }],
+        inputs: {
+            input: "",
+        },
+        execution_order: 2,
+        child_execution_order: 2,
+        run_type: "chain",
+        extra: expect.any(Object),
+        tags: [],
+        trace_id: firstCallParams.id,
+        dotted_order: expect.stringContaining(`${firstCallParams.dotted_order}.`),
+    });
+    expect(thirdCallParams).toMatchObject({
+        end_time: expect.any(Number),
+        outputs: { output: "Hello!" },
+        events: [
+            { name: "start", time: expect.any(String) },
+            { name: "end", time: expect.any(String) },
+        ],
+        inputs: {
+            input: [
+                {
+                    lc: 1,
+                    type: "constructor",
+                    id: ["langchain_core", "messages", "HumanMessage"],
+                    kwargs: {
+                        content: "Hello!",
+                        additional_kwargs: {},
+                        response_metadata: {},
+                    },
+                },
+            ],
+        },
+        trace_id: firstCallParams.id,
+        dotted_order: expect.stringContaining(`${firstCallParams.dotted_order}.`),
+        parent_run_id: firstCallParams.id,
+    });
+    expect(fourthCallParams).toMatchObject({
+        end_time: expect.any(Number),
+        inputs: {
+            args: [
+                {
+                    lc: 1,
+                    type: "constructor",
+                    id: ["langchain_core", "messages", "HumanMessage"],
+                    kwargs: {
+                        content: "Hello!",
+                        additional_kwargs: {},
+                        response_metadata: {},
+                    },
+                },
+                "mitochondria",
+            ],
+        },
+        outputs: {
+            outputs: [
+                "H",
+                "e",
+                "l",
+                "l",
+                "o",
+                "!",
+                "m",
+                "i",
+                "t",
+                "o",
+                "c",
+                "h",
+                "o",
+                "n",
+                "d",
+                "r",
+                "i",
+                "a",
+            ],
+        },
+        extra: expect.any(Object),
+        dotted_order: firstCallParams.dotted_order,
+        trace_id: firstCallParams.id,
+        tags: [],
+    });
+});

package/dist/tracers/tracer_langchain.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LangChainTracer = void 0;
 const langsmith_1 = require("langsmith");
+const run_trees_1 = require("langsmith/run_trees");
 const traceable_1 = require("langsmith/singletons/traceable");
 const env_js_1 = require("../utils/env.cjs");
 const base_js_1 = require("./base.cjs");
@@ -39,37 +40,9 @@ class LangChainTracer extends base_js_1.BaseTracer {
                 (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_SESSION");
         this.exampleId = exampleId;
         this.client = client ?? new langsmith_1.Client({});
-        // if we're inside traceable, we can obtain the traceable tree
-        // and populate the run map, which is used to correctly
-        // infer dotted order and execution order
-        const traceableTree = this.getTraceableRunTree();
+        const traceableTree = LangChainTracer.getTraceableRunTree();
         if (traceableTree) {
-            let rootRun = traceableTree;
-            const visited = new Set();
-            while (rootRun.parent_run) {
-                if (visited.has(rootRun.id))
-                    break;
-                visited.add(rootRun.id);
-                if (!rootRun.parent_run)
-                    break;
-                rootRun = rootRun.parent_run;
-            }
-            visited.clear();
-            const queue = [rootRun];
-            while (queue.length > 0) {
-                const current = queue.shift();
-                if (!current || visited.has(current.id))
-                    continue;
-                visited.add(current.id);
-                // @ts-expect-error Types of property 'events' are incompatible.
-                this.runMap.set(current.id, current);
-                if (current.child_runs) {
-                    queue.push(...current.child_runs);
-                }
-            }
-            this.client = traceableTree.client ?? this.client;
-            this.projectName = traceableTree.project_name ?? this.projectName;
-            this.exampleId = traceableTree.reference_example_id ?? this.exampleId;
+            this.updateFromRunTree(traceableTree);
         }
     }
     async _convertToCreate(run, example_id = undefined) {
@@ -105,7 +78,76 @@ class LangChainTracer extends base_js_1.BaseTracer {
     getRun(id) {
         return this.runMap.get(id);
     }
-    getTraceableRunTree() {
+    updateFromRunTree(runTree) {
+        let rootRun = runTree;
+        const visited = new Set();
+        while (rootRun.parent_run) {
+            if (visited.has(rootRun.id))
+                break;
+            visited.add(rootRun.id);
+            if (!rootRun.parent_run)
+                break;
+            rootRun = rootRun.parent_run;
+        }
+        visited.clear();
+        const queue = [rootRun];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current || visited.has(current.id))
+                continue;
+            visited.add(current.id);
+            // @ts-expect-error Types of property 'events' are incompatible.
+            this.runMap.set(current.id, current);
+            if (current.child_runs) {
+                queue.push(...current.child_runs);
+            }
+        }
+        this.client = runTree.client ?? this.client;
+        this.projectName = runTree.project_name ?? this.projectName;
+        this.exampleId = runTree.reference_example_id ?? this.exampleId;
+    }
+    convertToRunTree(id) {
+        const runTreeMap = {};
+        const runTreeList = [];
+        for (const [id, run] of this.runMap) {
+            // by converting the run map to a run tree, we are doing a copy
+            // thus, any mutation performed on the run tree will not be reflected
+            // back in the run map
+            // TODO: Stop using `this.runMap` in favour of LangSmith's `RunTree`
+            const runTree = new run_trees_1.RunTree({
+                ...run,
+                child_runs: [],
+                parent_run: undefined,
+                // inherited properties
+                client: this.client,
+                project_name: this.projectName,
+                reference_example_id: this.exampleId,
+                tracingEnabled: true,
+            });
+            runTreeMap[id] = runTree;
+            runTreeList.push([id, run.dotted_order]);
+        }
+        runTreeList.sort((a, b) => {
+            if (!a[1] || !b[1])
+                return 0;
+            return a[1].localeCompare(b[1]);
+        });
+        for (const [id] of runTreeList) {
+            const run = this.runMap.get(id);
+            const runTree = runTreeMap[id];
+            if (!run || !runTree)
+                continue;
+            if (run.parent_run_id) {
+                const parentRunTree = runTreeMap[run.parent_run_id];
+                if (parentRunTree) {
+                    parentRunTree.child_runs.push(runTree);
+                    runTree.parent_run = parentRunTree;
+                }
+            }
+        }
+        return runTreeMap[id];
+    }
+    static getTraceableRunTree() {
         try {
             return (0, traceable_1.getCurrentRunTree)();
         }

package/dist/tracers/tracer_langchain.d.ts

@@ -36,5 +36,7 @@ export declare class LangChainTracer extends BaseTracer implements LangChainTrac
     onRunCreate(run: Run): Promise<void>;
     onRunUpdate(run: Run): Promise<void>;
     getRun(id: string): Run | undefined;
-    getTraceableRunTree(): RunTree | undefined;
+    updateFromRunTree(runTree: RunTree): void;
+    convertToRunTree(id: string): RunTree | undefined;
+    static getTraceableRunTree(): RunTree | undefined;
 }