@langchain/core 0.2.18 → 0.2.19

package/dist/runnables/tests/runnable_stream_log.test.d.ts

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

package/dist/runnables/tests/runnable_stream_log.test.js

@@ -1,71 +0,0 @@
-/* eslint-disable no-promise-executor-return */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { test } from "@jest/globals";
-import { ChatPromptTemplate, HumanMessagePromptTemplate, PromptTemplate, SystemMessagePromptTemplate, } from "../../prompts/index.js";
-import { Document } from "../../documents/document.js";
-import { RunnableSequence, RunnableMap } from "../base.js";
-import { FakeLLM, FakeChatModel, FakeRetriever, } from "../../utils/testing/index.js";
-test("Runnable streamLog method", async () => {
-    const promptTemplate = PromptTemplate.fromTemplate("{input}");
-    const llm = new FakeLLM({});
-    const runnable = promptTemplate.pipe(llm);
-    const result = await runnable.streamLog({ input: "Hello world!" });
-    let finalState;
-    for await (const chunk of result) {
-        if (finalState === undefined) {
-            finalState = chunk;
-        }
-        else {
-            finalState = finalState.concat(chunk);
-        }
-    }
-    expect(finalState.state.final_output).toEqual({
-        output: "Hello world!",
-    });
-});
-test("Runnable streamLog method with a more complicated sequence", async () => {
-    const promptTemplate = ChatPromptTemplate.fromMessages([
-        SystemMessagePromptTemplate.fromTemplate(`You are a nice assistant.`),
-        HumanMessagePromptTemplate.fromTemplate(`Context:\n{documents}\n\nQuestion:\n{question}`),
-    ]);
-    const llm = new FakeChatModel({});
-    const retrieverOutputDocs = [
-        new Document({ pageContent: "foo" }),
-        new Document({ pageContent: "bar" }),
-    ];
-    const inputs = {
-        question: (input) => input,
-        documents: RunnableSequence.from([
-            new FakeRetriever({
-                output: retrieverOutputDocs,
-            }),
-            (docs) => JSON.stringify(docs),
-        ]).withConfig({ runName: "CUSTOM_NAME" }),
-        extraField: new FakeLLM({
-            response: "testing",
-        }).withConfig({ tags: ["only_one"] }),
-    };
-    const runnable = new RunnableMap({
-        steps: inputs,
-    })
-        .pipe(promptTemplate)
-        .pipe(llm);
-    const stream = await runnable.streamLog("Do you know the Muffin Man?", {}, {
-        includeTags: ["only_one"],
-        includeNames: ["CUSTOM_NAME"],
-    });
-    let finalState;
-    for await (const chunk of stream) {
-        if (finalState === undefined) {
-            finalState = chunk;
-        }
-        else {
-            finalState = finalState.concat(chunk);
-        }
-    }
-    expect(finalState.state.logs.FakeLLM).toBeDefined();
-    expect(finalState.state.logs.FakeLLM.final_output.generations[0][0]
-        .text).toEqual("testing");
-    expect(finalState.state.logs.CUSTOM_NAME).toBeDefined();
-    expect(finalState.state.logs.CUSTOM_NAME.final_output.output).toEqual(JSON.stringify(retrieverOutputDocs));
-});

package/dist/runnables/tests/runnable_tools.test.d.ts

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

package/dist/runnables/tests/runnable_tools.test.js

@@ -1,149 +0,0 @@
-import { z } from "zod";
-import { RunnableLambda, RunnableToolLike } from "../base.js";
-import { FakeRetriever } from "../../utils/testing/index.js";
-import { Document } from "../../documents/document.js";
-test("Runnable asTool works", async () => {
-    const schema = z.object({
-        foo: z.string(),
-    });
-    const runnable = RunnableLambda.from((input, config) => {
-        return `${input.foo}${config?.configurable.foo}`;
-    });
-    const tool = runnable.asTool({
-        schema,
-    });
-    expect(tool).toBeInstanceOf(RunnableToolLike);
-    expect(tool.schema).toBe(schema);
-    expect(tool.name).toBe(runnable.getName());
-});
-test("Runnable asTool works with all populated fields", async () => {
-    const schema = z.object({
-        foo: z.string(),
-    });
-    const runnable = RunnableLambda.from((input, config) => {
-        return `${input.foo}${config?.configurable.foo}`;
-    });
-    const tool = runnable.asTool({
-        schema,
-        name: "test",
-        description: "test",
-    });
-    expect(tool).toBeInstanceOf(RunnableToolLike);
-    expect(tool.schema).toBe(schema);
-    expect(tool.description).toBe("test");
-    expect(tool.name).toBe("test");
-});
-test("Runnable asTool can invoke", async () => {
-    const schema = z.object({
-        foo: z.string(),
-    });
-    const runnable = RunnableLambda.from((input, config) => {
-        return `${input.foo}${config?.configurable.foo}`;
-    });
-    const tool = runnable.asTool({
-        schema,
-    });
-    const toolResponse = await tool.invoke({
-        foo: "bar",
-    }, {
-        configurable: {
-            foo: "bar",
-        },
-    });
-    expect(toolResponse).toBe("barbar");
-});
-test("asTool should type error with mismatched schema", async () => {
-    // asTool infers the type of the Zod schema from the existing runnable's RunInput generic.
-    // If the Zod schema does not match the RunInput, it should throw a type error.
-    const schema = z.object({
-        foo: z.string(),
-    });
-    const runnable = RunnableLambda.from((input, config) => {
-        return `${input.bar}${config?.configurable.foo}`;
-    });
-    runnable.asTool({
-        // @ts-expect-error - Should error. If this does not give a type error, the generics/typing of `asTool` is broken.
-        schema,
-    });
-});
-test("Create a runnable tool directly from RunnableToolLike", async () => {
-    const schema = z.object({
-        foo: z.string(),
-    });
-    const adderFunc = (_) => {
-        return Promise.resolve(true);
-    };
-    const tool = new RunnableToolLike({
-        schema,
-        name: "test",
-        description: "test",
-        bound: RunnableLambda.from(adderFunc),
-    });
-    const result = await tool.invoke({ foo: "bar" });
-    expect(result).toBe(true);
-});
-test("asTool can take a single string input", async () => {
-    const firstRunnable = RunnableLambda.from((input) => {
-        return `${input}a`;
-    });
-    const secondRunnable = RunnableLambda.from((input) => {
-        return `${input}z`;
-    });
-    const runnable = firstRunnable.pipe(secondRunnable);
-    const asTool = runnable.asTool({
-        schema: z.string(),
-    });
-    const result = await asTool.invoke("b");
-    expect(result).toBe("baz");
-});
-test("Runnable asTool uses Zod schema description if not provided", async () => {
-    const description = "Test schema";
-    const schema = z
-        .object({
-        foo: z.string(),
-    })
-        .describe(description);
-    const runnable = RunnableLambda.from((input, config) => {
-        return `${input.foo}${config?.configurable.foo}`;
-    });
-    const tool = runnable.asTool({
-        schema,
-    });
-    expect(tool.description).toBe(description);
-});
-test("Runnable asTool can accept a string zod schema", async () => {
-    const lambda = RunnableLambda.from((input) => {
-        return `${input}a`;
-    }).asTool({
-        name: "string_tool",
-        description: "A tool that appends 'a' to the input string",
-        schema: z.string(),
-    });
-    const result = await lambda.invoke("b");
-    expect(result).toBe("ba");
-});
-test("Runnables which dont accept ToolCalls as inputs can accept ToolCalls", async () => {
-    const pageContent = "Dogs are pretty cool, man!";
-    const retriever = new FakeRetriever({
-        output: [
-            new Document({
-                pageContent,
-            }),
-        ],
-    });
-    const tool = retriever.asTool({
-        name: "pet_info_retriever",
-        description: "Get information about pets.",
-        schema: z.string(),
-    });
-    const result = await tool.invoke({
-        type: "tool_call",
-        name: "pet_info_retriever",
-        args: {
-            input: "dogs",
-        },
-        id: "string",
-    });
-    expect(result).toHaveLength(1);
-    expect(result[0].pageContent).toBe(pageContent);
-});

package/dist/runnables/tests/runnable_tracing.int.test.d.ts

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

package/dist/runnables/tests/runnable_tracing.int.test.js

@@ -1,37 +0,0 @@
-import { Client } from "langsmith";
-import { LangChainTracer } from "../../tracers/tracer_langchain.js";
-import { BaseOutputParser, } from "../../output_parsers/base.js";
-import { FakeChatModel } from "../../utils/testing/index.js";
-import { getEnvironmentVariable } from "../../utils/env.js";
-class FakeDateOutputParser extends BaseOutputParser {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain_core", "output_parsers", "testing"]
-        });
-    }
-    async parse(_text) {
-        return new Date();
-    }
-    getFormatInstructions(_options) {
-        return "";
-    }
-}
-test("Should handle tracing with a date output", async () => {
-    const client = new Client({
-        apiUrl: getEnvironmentVariable("LANGCHAIN_ENDPOINT"),
-        apiKey: getEnvironmentVariable("LANGCHAIN_API_KEY"),
-    });
-    const tracer = new LangChainTracer({
-        projectName: getEnvironmentVariable("LANGCHAIN_SESSION"),
-        client,
-    });
-    const model = new FakeChatModel({});
-    const parser = new FakeDateOutputParser();
-    const chain = model.pipe(parser);
-    const result = await chain.invoke("test", { callbacks: [tracer] });
-    console.log(result);
-});

package/dist/runnables/tests/runnable_with_fallbacks.test.d.ts

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

package/dist/runnables/tests/runnable_with_fallbacks.test.js

@@ -1,36 +0,0 @@
-/* eslint-disable no-promise-executor-return */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { test } from "@jest/globals";
-import { FakeLLM } from "../../utils/testing/index.js";
-test("RunnableWithFallbacks", async () => {
-    const llm = new FakeLLM({
-        thrownErrorString: "Bad error!",
-    });
-    await expect(async () => {
-        const result1 = await llm.invoke("What up");
-        console.log(result1);
-    }).rejects.toThrow();
-    const llmWithFallbacks = llm.withFallbacks({
-        fallbacks: [new FakeLLM({})],
-    });
-    const result2 = await llmWithFallbacks.invoke("What up");
-    expect(result2).toEqual("What up");
-});
-test("RunnableWithFallbacks batch", async () => {
-    const llm = new FakeLLM({
-        thrownErrorString: "Bad error!",
-    });
-    await expect(async () => {
-        const result1 = await llm.batch(["What up"]);
-        console.log(result1);
-    }).rejects.toThrow();
-    const llmWithFallbacks = llm.withFallbacks({
-        fallbacks: [new FakeLLM({})],
-    });
-    const result2 = await llmWithFallbacks.batch([
-        "What up 1",
-        "What up 2",
-        "What up 3",
-    ]);
-    expect(result2).toEqual(["What up 1", "What up 2", "What up 3"]);
-});

package/dist/singletons/tests/async_local_storage.test.d.ts

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

package/dist/singletons/tests/async_local_storage.test.js

@@ -1,153 +0,0 @@
-import { test, expect } from "@jest/globals";
-import { v4 } from "uuid";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { AsyncLocalStorageProviderSingleton } from "../index.js";
-import { RunnableLambda } from "../../runnables/base.js";
-import { FakeListChatModel } from "../../utils/testing/index.js";
-import { getCallbackManagerForConfig } from "../../runnables/config.js";
-import { BaseCallbackHandler } from "../../callbacks/base.js";
-class FakeCallbackHandler extends BaseCallbackHandler {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: `fake-${v4()}`
-        });
-    }
-}
-test("Config should be automatically populated after setting global async local storage", async () => {
-    const inner = RunnableLambda.from((_, config) => config);
-    const outer = RunnableLambda.from(async (input) => {
-        const res = await inner.invoke(input);
-        return res;
-    });
-    const res1 = await outer.invoke({ hi: true }, {
-        configurable: {
-            sampleKey: "sampleValue",
-        },
-        tags: ["tester"],
-    });
-    expect(res1?.tags).toEqual([]);
-    AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
-    const res2 = await outer.invoke({ hi: true }, {
-        configurable: {
-            sampleKey: "sampleValue",
-        },
-        tags: ["tester"],
-    });
-    expect(res2?.tags).toEqual(["tester"]);
-    const stream = await outer.stream({ hi2: true }, {
-        configurable: {
-            sampleKey: "sampleValue",
-        },
-        tags: ["stream_tester"],
-    });
-    const chunks = [];
-    for await (const chunk of stream) {
-        chunks.push(chunk);
-    }
-    expect(chunks.length).toEqual(1);
-    expect(chunks[0]).toEqual(expect.objectContaining({
-        configurable: {
-            sampleKey: "sampleValue",
-        },
-        tags: ["stream_tester"],
-    }));
-    const outer2 = RunnableLambda.from(async () => inner);
-    const res3 = await outer2.invoke({}, {
-        configurable: {
-            sampleKey: "sampleValue",
-        },
-        tags: ["test_recursive"],
-    });
-    expect(res3?.tags).toEqual(["test_recursive"]);
-    const stream2 = await outer2.stream({}, {
-        configurable: {
-            sampleKey: "sampleValue",
-        },
-        tags: ["stream_test_recursive"],
-    });
-    const chunks2 = [];
-    for await (const chunk of stream2) {
-        chunks2.push(chunk);
-    }
-    expect(chunks2.length).toEqual(1);
-    expect(chunks2[0]).toEqual(expect.objectContaining({
-        configurable: {
-            sampleKey: "sampleValue",
-        },
-        tags: ["stream_test_recursive"],
-    }));
-    const inner2 = RunnableLambda.from((_, config) => config).withConfig({
-        runName: "inner_test_run",
-    });
-    const outer3 = RunnableLambda.from(async (input) => {
-        const res = await inner2.invoke(input);
-        return res;
-    });
-    const res4 = await outer3.invoke({ hi: true }, {
-        configurable: {
-            sampleKey: "sampleValue",
-        },
-        tags: ["tester_with_config"],
-    });
-    expect(res4?.tags).toEqual(["tester_with_config"]);
-    const chatModel = new FakeListChatModel({ responses: ["test"] });
-    const outer4 = RunnableLambda.from(async () => {
-        const res = await chatModel.invoke("hey");
-        return res;
-    });
-    const eventStream = await outer4.streamEvents({ hi: true }, { version: "v1" });
-    const events = [];
-    for await (const event of eventStream) {
-        events.push(event);
-    }
-    expect(events.filter((event) => event.event === "on_llm_start").length).toEqual(1);
-});
-test("Runnable streamEvents method with streaming nested in a RunnableLambda", async () => {
-    AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
-    const chat = new FakeListChatModel({
-        responses: ["Hello"],
-    });
-    const outerRunId = v4();
-    const innerRunId = v4();
-    const innerRunId2 = v4();
-    const dummyHandler = new FakeCallbackHandler();
-    const myFunc = async (input) => {
-        const outerCallbackManager = await getCallbackManagerForConfig(AsyncLocalStorageProviderSingleton.getRunnableConfig());
-        expect(outerCallbackManager?.getParentRunId()).toEqual(outerRunId);
-        const nestedLambdaWithOverriddenCallbacks = RunnableLambda.from(async (_, config) => {
-            expect(config?.callbacks?.handlers).toEqual([]);
-        });
-        await nestedLambdaWithOverriddenCallbacks.invoke(input, {
-            runId: innerRunId,
-            callbacks: [],
-        });
-        const nestedLambdaWithoutOverriddenCallbacks = RunnableLambda.from(async (_, config) => {
-            const innerCallbackManager = await getCallbackManagerForConfig(AsyncLocalStorageProviderSingleton.getRunnableConfig());
-            expect(innerCallbackManager?.getParentRunId()).toEqual(innerRunId2);
-            expect(config?.callbacks?.handlers).toContain(dummyHandler);
-        });
-        await nestedLambdaWithoutOverriddenCallbacks.invoke(input, {
-            runId: innerRunId2,
-        });
-        for await (const _ of await chat.stream(input)) {
-            // no-op
-        }
-    };
-    const myNestedLambda = RunnableLambda.from(myFunc);
-    const events = [];
-    for await (const event of myNestedLambda.streamEvents("hello", {
-        version: "v1",
-        runId: outerRunId,
-        callbacks: [dummyHandler],
-    })) {
-        events.push(event);
-    }
-    const chatModelStreamEvent = events.find((event) => {
-        return event.event === "on_llm_stream";
-    });
-    expect(chatModelStreamEvent).toBeDefined();
-});

package/dist/structured_query/tests/utils.test.d.ts

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

package/dist/structured_query/tests/utils.test.js

@@ -1,47 +0,0 @@
-/* eslint-disable no-process-env */
-import { test } from "@jest/globals";
-import { castValue, isFloat, isInt, isString } from "../utils.js";
-test("Casting values correctly", () => {
-    const stringString = [
-        "string",
-        "test",
-        "this is a string",
-        "        ",
-        "\n\n\n\n\n\n",
-        `asdf
-    zxcv`,
-    ];
-    const intString = [
-        "1a",
-        "2b",
-        "3c",
-        "a4",
-        `123
-    asdf`,
-    ];
-    const floatString = ["1.1a", "2.2b", "3.3c", "c4.4"];
-    const intInt = ["1", 2, 3];
-    const floatFloat = ["1.1", 2.2, 3.3];
-    stringString.map(castValue).forEach((value) => {
-        expect(typeof value).toBe("string");
-        expect(isString(value)).toBe(true);
-    });
-    intString.map(castValue).forEach((value) => {
-        expect(typeof value).toBe("string");
-        expect(isString(value)).toBe(true);
-        expect(isInt(value)).toBe(false);
-    });
-    floatString.map(castValue).forEach((value) => {
-        expect(typeof value).toBe("string");
-        expect(isString(value)).toBe(true);
-        expect(isFloat(value)).toBe(false);
-    });
-    intInt.map(castValue).forEach((value) => {
-        expect(typeof value).toBe("number");
-        expect(isInt(value)).toBe(true);
-    });
-    floatFloat.map(castValue).forEach((value) => {
-        expect(typeof value).toBe("number");
-        expect(isFloat(value)).toBe(true);
-    });
-});

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

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

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

@@ -1,85 +0,0 @@
-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");
-});
-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/tracers/tests/langchain_tracer.int.test.d.ts

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

package/dist/tracers/tests/langchain_tracer.int.test.js

@@ -1,74 +0,0 @@
-/* eslint-disable no-process-env */
-import * as uuid from "uuid";
-import { test } from "@jest/globals";
-import { LangChainTracer } from "../tracer_langchain.js";
-import { HumanMessage } from "../../messages/index.js";
-const serialized = {
-    lc: 1,
-    type: "constructor",
-    id: ["test"],
-    kwargs: {},
-};
-test("LangChain V2 tracer does not throw errors for its methods", async () => {
-    const tracer = new LangChainTracer({
-        projectName: `JS Int Test - ${uuid.v4()}`,
-    });
-    const chainRunId = uuid.v4();
-    const toolRunId = uuid.v4();
-    const llmRunId = uuid.v4();
-    const chatRunId = uuid.v4();
-    await tracer.handleChainStart(serialized, { foo: "bar" }, chainRunId);
-    await tracer.handleToolStart(serialized, "test", toolRunId, chainRunId);
-    await tracer.handleLLMStart(serialized, ["test"], llmRunId, toolRunId);
-    await tracer.handleLLMEnd({ generations: [[]] }, llmRunId);
-    await tracer.handleChatModelStart(serialized, [[new HumanMessage("I'm a human.")]], chatRunId);
-    await tracer.handleLLMEnd({ generations: [[]] }, chatRunId);
-    await tracer.handleToolEnd("output", toolRunId);
-    const llmRunId2 = uuid.v4();
-    await tracer.handleLLMStart(serialized, ["test"], llmRunId2, chainRunId);
-    await tracer.handleLLMEnd({ generations: [[]] }, llmRunId2);
-    await tracer.handleChainEnd({ foo: "bar" }, chainRunId);
-    const llmRunId3 = uuid.v4();
-    await tracer.handleLLMStart(serialized, ["test"], llmRunId3);
-    await tracer.handleLLMEnd({ generations: [[]] }, llmRunId3);
-});
-class FakeTracer extends LangChainTracer {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "createOperations", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        Object.defineProperty(this, "updateOperations", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-    }
-    async onRunCreate(run) {
-        this.createOperations[run.id] = run;
-    }
-    async onRunUpdate(run) {
-        this.updateOperations[run.id] = run;
-    }
-}
-test("LangChain V2 tracer creates and updates runs with trace_id and dotted_order", async () => {
-    const tracer = new FakeTracer({
-        projectName: `JS Int Test - ${uuid.v4()}`,
-    });
-    const chainRunId = uuid.v4();
-    const llmRunId = uuid.v4();
-    await tracer.handleChainStart(serialized, { foo: "bar" }, chainRunId);
-    await tracer.handleLLMStart(serialized, ["test"], llmRunId, chainRunId);
-    await tracer.handleLLMEnd({ generations: [[]] }, llmRunId);
-    await tracer.handleChainEnd({ foo: "bar" }, chainRunId);
-    expect(tracer.createOperations[chainRunId].trace_id).toBeDefined();
-    expect(tracer.createOperations[chainRunId].trace_id).toEqual(chainRunId);
-    expect(tracer.createOperations[chainRunId].dotted_order).toBeDefined();
-    expect(tracer.updateOperations[llmRunId].trace_id).toBeDefined();
-    expect(tracer.updateOperations[llmRunId].trace_id).toEqual(chainRunId);
-    expect(tracer.updateOperations[llmRunId].dotted_order).toBeDefined();
-});

package/dist/tracers/tests/langsmith_interop.test.d.ts

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