@langchain/core 0.2.0 → 0.2.1

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

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

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

@@ -0,0 +1,282 @@
+/* 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, FakeStreamingLLM, FakeChatModel, FakeRetriever, } from "../../utils/testing/index.js";
+import { SystemMessage, HumanMessage } from "../../messages/index.js";
+import { CommaSeparatedListOutputParser } from "../../output_parsers/list.js";
+import { ChatPromptValue } from "../../prompt_values.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));
+});
+test("Test stream log aggregation", async () => {
+    const prompt = ChatPromptTemplate.fromMessages([
+        ["system", "You are a nice assistant"],
+        ["human", "{question}"],
+    ]);
+    const llm = new FakeStreamingLLM({
+        responses: ["tomato, lettuce, onion"],
+    });
+    const parser = new CommaSeparatedListOutputParser({});
+    const chain = prompt.pipe(llm).pipe(parser);
+    const logStream = await chain.streamLog({
+        question: "what is up?",
+    });
+    const chunks = [];
+    for await (const chunk of logStream) {
+        chunks.push(chunk);
+    }
+    expect(chunks).toMatchObject([
+        {
+            ops: [
+                {
+                    op: "replace",
+                    path: "",
+                    value: {
+                        id: expect.any(String),
+                        streamed_output: [],
+                        logs: {},
+                    },
+                },
+            ],
+        },
+        {
+            ops: [
+                {
+                    op: "add",
+                    path: "/logs/ChatPromptTemplate",
+                    value: {
+                        id: expect.any(String),
+                        name: "ChatPromptTemplate",
+                        type: "prompt",
+                        tags: ["seq:step:1"],
+                        metadata: {},
+                        start_time: expect.any(String),
+                        streamed_output: [],
+                        streamed_output_str: [],
+                    },
+                },
+            ],
+        },
+        {
+            ops: [
+                {
+                    op: "add",
+                    path: "/logs/ChatPromptTemplate/final_output",
+                    value: new ChatPromptValue([
+                        new SystemMessage("You are a nice assistant"),
+                        new HumanMessage("what is up?"),
+                    ]),
+                },
+                {
+                    op: "add",
+                    path: "/logs/ChatPromptTemplate/end_time",
+                    value: expect.any(String),
+                },
+            ],
+        },
+        {
+            ops: [
+                {
+                    op: "add",
+                    path: "/logs/FakeStreamingLLM",
+                    value: {
+                        id: expect.any(String),
+                        name: "FakeStreamingLLM",
+                        type: "llm",
+                        tags: ["seq:step:2"],
+                        metadata: {},
+                        start_time: expect.any(String),
+                        streamed_output: [],
+                        streamed_output_str: [],
+                    },
+                },
+            ],
+        },
+        {
+            ops: [
+                {
+                    op: "add",
+                    path: "/logs/CommaSeparatedListOutputParser",
+                    value: {
+                        id: expect.any(String),
+                        name: "CommaSeparatedListOutputParser",
+                        type: "parser",
+                        tags: ["seq:step:3"],
+                        metadata: {},
+                        start_time: expect.any(String),
+                        streamed_output: [],
+                        streamed_output_str: [],
+                    },
+                },
+            ],
+        },
+        {
+            ops: [
+                {
+                    op: "add",
+                    path: "/logs/CommaSeparatedListOutputParser/streamed_output/-",
+                    value: ["tomato"],
+                },
+            ],
+        },
+        {
+            ops: [
+                {
+                    op: "add",
+                    path: "/streamed_output/-",
+                    value: ["tomato"],
+                },
+            ],
+        },
+        {
+            ops: [
+                {
+                    op: "add",
+                    path: "/logs/CommaSeparatedListOutputParser/streamed_output/-",
+                    value: ["lettuce"],
+                },
+            ],
+        },
+        {
+            ops: [
+                {
+                    op: "add",
+                    path: "/streamed_output/-",
+                    value: ["lettuce"],
+                },
+            ],
+        },
+        {
+            ops: [
+                {
+                    op: "add",
+                    path: "/logs/FakeStreamingLLM/final_output",
+                    value: {
+                        generations: [
+                            [
+                                {
+                                    text: "tomato, lettuce, onion",
+                                    generationInfo: {},
+                                },
+                            ],
+                        ],
+                    },
+                },
+                {
+                    op: "add",
+                    path: "/logs/FakeStreamingLLM/end_time",
+                    value: expect.any(String),
+                },
+            ],
+        },
+        {
+            ops: [
+                {
+                    op: "add",
+                    path: "/logs/CommaSeparatedListOutputParser/streamed_output/-",
+                    value: ["onion"],
+                },
+            ],
+        },
+        {
+            ops: [
+                {
+                    op: "add",
+                    path: "/streamed_output/-",
+                    value: ["onion"],
+                },
+            ],
+        },
+        {
+            ops: [
+                {
+                    op: "add",
+                    path: "/logs/CommaSeparatedListOutputParser/final_output",
+                    value: {
+                        output: ["tomato", "lettuce", "onion"],
+                    },
+                },
+                {
+                    op: "add",
+                    path: "/logs/CommaSeparatedListOutputParser/end_time",
+                    value: expect.any(String),
+                },
+            ],
+        },
+        {
+            ops: [
+                {
+                    op: "replace",
+                    path: "/final_output",
+                    value: {
+                        output: ["tomato", "lettuce", "onion"],
+                    },
+                },
+            ],
+        },
+    ]);
+});

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

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

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

@@ -0,0 +1,37 @@
+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

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

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

@@ -0,0 +1,36 @@
+/* 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/runnables/utils.d.ts

@@ -1,4 +1,4 @@
-import { StreamEvent } from "../tracers/log_stream.js";
+import { StreamEvent } from "../tracers/event_stream.js";
 import type { RunnableInterface } from "./types.js";
 export declare function isRunnableInterface(thing: any): thing is RunnableInterface;
 /**

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

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

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

@@ -0,0 +1,120 @@
+import { test, expect } from "@jest/globals";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorageProviderSingleton } from "../index.js";
+import { RunnableLambda } from "../../runnables/base.js";
+import { FakeListChatModel } from "../../utils/testing/index.js";
+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) {
+        console.log(chunk);
+        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) {
+        console.log(chunk);
+        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) {
+        console.log(event);
+        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 myFunc = async (input) => {
+        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",
+    })) {
+        console.log(event);
+        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

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

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

@@ -0,0 +1,47 @@
+/* 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);
+    });
+});