@langchain/core 0.2.0-rc.0 → 0.2.1

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

@@ -0,0 +1,378 @@
+import { test, expect, jest } from "@jest/globals";
+import * as uuid from "uuid";
+import { Document } from "../../documents/document.js";
+import { HumanMessage } from "../../messages/index.js";
+import { FakeTracer } from "../../utils/testing/index.js";
+const _DATE = 1620000000000;
+Date.now = jest.fn(() => _DATE);
+const serialized = {
+    lc: 1,
+    type: "constructor",
+    id: ["test"],
+    kwargs: {},
+};
+test("Test LLMRun", async () => {
+    const tracer = new FakeTracer();
+    const runId = uuid.v4();
+    await tracer.handleLLMStart(serialized, ["test"], runId);
+    await tracer.handleLLMEnd({ generations: [] }, runId);
+    expect(tracer.runs.length).toBe(1);
+    const run = tracer.runs[0];
+    const compareRun = {
+        id: runId,
+        name: "test",
+        start_time: _DATE,
+        end_time: _DATE,
+        execution_order: 1,
+        child_execution_order: 1,
+        serialized,
+        events: [
+            {
+                name: "start",
+                time: "2021-05-03T00:00:00.000Z",
+            },
+            {
+                name: "end",
+                time: "2021-05-03T00:00:00.000Z",
+            },
+        ],
+        inputs: { prompts: ["test"] },
+        run_type: "llm",
+        outputs: { generations: [] },
+        child_runs: [],
+        extra: {},
+        tags: [],
+        dotted_order: `20210503T000000000001Z${runId}`,
+        trace_id: runId,
+    };
+    expect(run).toEqual(compareRun);
+});
+test("Test Chat Model Run", async () => {
+    const tracer = new FakeTracer();
+    const runId = uuid.v4();
+    const messages = [[new HumanMessage("Avast")]];
+    await tracer.handleChatModelStart(serialized, messages, runId);
+    await tracer.handleLLMEnd({ generations: [] }, runId);
+    expect(tracer.runs.length).toBe(1);
+    const run = tracer.runs[0];
+    expect(run).toMatchInlineSnapshot({
+        id: expect.any(String),
+    }, `
+    {
+      "child_execution_order": 1,
+      "child_runs": [],
+      "dotted_order": "20210503T000000000001Z${runId}",
+      "end_time": 1620000000000,
+      "events": [
+        {
+          "name": "start",
+          "time": "2021-05-03T00:00:00.000Z",
+        },
+        {
+          "name": "end",
+          "time": "2021-05-03T00:00:00.000Z",
+        },
+      ],
+      "execution_order": 1,
+      "extra": {},
+      "id": Any<String>,
+      "inputs": {
+        "messages": [
+          [
+            {
+              "id": [
+                "langchain_core",
+                "messages",
+                "HumanMessage",
+              ],
+              "kwargs": {
+                "additional_kwargs": {},
+                "content": "Avast",
+                "response_metadata": {},
+              },
+              "lc": 1,
+              "type": "constructor",
+            },
+          ],
+        ],
+      },
+      "name": "test",
+      "outputs": {
+        "generations": [],
+      },
+      "parent_run_id": undefined,
+      "run_type": "llm",
+      "serialized": {
+        "id": [
+          "test",
+        ],
+        "kwargs": {},
+        "lc": 1,
+        "type": "constructor",
+      },
+      "start_time": 1620000000000,
+      "tags": [],
+      "trace_id": "${runId}",
+    }
+  `);
+});
+test("Test LLM Run no start", async () => {
+    const tracer = new FakeTracer();
+    const runId = uuid.v4();
+    await expect(tracer.handleLLMEnd({ generations: [] }, runId)).rejects.toThrow("No LLM run to end");
+});
+test("Test Chain Run", async () => {
+    const tracer = new FakeTracer();
+    const runId = uuid.v4();
+    const compareRun = {
+        id: runId,
+        name: "test",
+        start_time: _DATE,
+        end_time: _DATE,
+        execution_order: 1,
+        child_execution_order: 1,
+        serialized,
+        events: [
+            {
+                name: "start",
+                time: "2021-05-03T00:00:00.000Z",
+            },
+            {
+                name: "end",
+                time: "2021-05-03T00:00:00.000Z",
+            },
+        ],
+        inputs: { foo: "bar" },
+        outputs: { foo: "bar" },
+        run_type: "chain",
+        child_runs: [],
+        extra: {},
+        tags: [],
+        dotted_order: `20210503T000000000001Z${runId}`,
+        trace_id: runId,
+    };
+    await tracer.handleChainStart(serialized, { foo: "bar" }, runId);
+    await tracer.handleChainEnd({ foo: "bar" }, runId);
+    expect(tracer.runs.length).toBe(1);
+    const run = tracer.runs[0];
+    expect(run).toEqual(compareRun);
+});
+test("Test Tool Run", async () => {
+    const tracer = new FakeTracer();
+    const runId = uuid.v4();
+    const compareRun = {
+        id: runId,
+        name: "test",
+        start_time: _DATE,
+        end_time: _DATE,
+        execution_order: 1,
+        child_execution_order: 1,
+        serialized,
+        events: [
+            {
+                name: "start",
+                time: "2021-05-03T00:00:00.000Z",
+            },
+            {
+                name: "end",
+                time: "2021-05-03T00:00:00.000Z",
+            },
+        ],
+        inputs: { input: "test" },
+        outputs: { output: "output" },
+        run_type: "tool",
+        child_runs: [],
+        extra: {},
+        tags: [],
+        dotted_order: `20210503T000000000001Z${runId}`,
+        trace_id: runId,
+    };
+    await tracer.handleToolStart(serialized, "test", runId);
+    await tracer.handleToolEnd("output", runId);
+    expect(tracer.runs.length).toBe(1);
+    const run = tracer.runs[0];
+    expect(run).toEqual(compareRun);
+});
+test("Test Retriever Run", async () => {
+    const tracer = new FakeTracer();
+    const runId = uuid.v4();
+    const document = new Document({
+        pageContent: "test",
+        metadata: { test: "test" },
+    });
+    const compareRun = {
+        id: runId,
+        name: "test",
+        start_time: _DATE,
+        end_time: _DATE,
+        execution_order: 1,
+        child_execution_order: 1,
+        serialized,
+        events: [
+            {
+                name: "start",
+                time: "2021-05-03T00:00:00.000Z",
+            },
+            {
+                name: "end",
+                time: "2021-05-03T00:00:00.000Z",
+            },
+        ],
+        inputs: { query: "bar" },
+        outputs: { documents: [document] },
+        run_type: "retriever",
+        child_runs: [],
+        extra: {},
+        tags: [],
+        dotted_order: `20210503T000000000001Z${runId}`,
+        trace_id: runId,
+    };
+    await tracer.handleRetrieverStart(serialized, "bar", runId);
+    await tracer.handleRetrieverEnd([document], runId);
+    expect(tracer.runs.length).toBe(1);
+    const run = tracer.runs[0];
+    expect(run).toEqual(compareRun);
+});
+test("Test nested runs", async () => {
+    const tracer = new FakeTracer();
+    const chainRunId = uuid.v4();
+    const toolRunId = uuid.v4();
+    const llmRunId = uuid.v4();
+    await tracer.handleChainStart(serialized, { foo: "bar" }, chainRunId);
+    await tracer.handleToolStart({ ...serialized, id: ["test_tool"] }, "test", toolRunId, chainRunId);
+    await tracer.handleLLMStart({ ...serialized, id: ["test_llm_child_run"] }, ["test"], llmRunId, toolRunId);
+    await tracer.handleLLMEnd({ generations: [[]] }, llmRunId);
+    await tracer.handleToolEnd("output", toolRunId);
+    const llmRunId2 = uuid.v4();
+    await tracer.handleLLMStart({ ...serialized, id: ["test_llm2"] }, ["test"], llmRunId2, chainRunId);
+    await tracer.handleLLMEnd({ generations: [[]] }, llmRunId2);
+    await tracer.handleChainEnd({ foo: "bar" }, chainRunId);
+    const compareRun = {
+        child_runs: [
+            {
+                id: toolRunId,
+                name: "test_tool",
+                parent_run_id: chainRunId,
+                child_runs: [
+                    {
+                        id: llmRunId,
+                        name: "test_llm_child_run",
+                        parent_run_id: toolRunId,
+                        end_time: 1620000000000,
+                        execution_order: 3,
+                        child_execution_order: 3,
+                        inputs: { prompts: ["test"] },
+                        outputs: {
+                            generations: [[]],
+                        },
+                        serialized: { ...serialized, id: ["test_llm_child_run"] },
+                        events: [
+                            {
+                                name: "start",
+                                time: "2021-05-03T00:00:00.000Z",
+                            },
+                            {
+                                name: "end",
+                                time: "2021-05-03T00:00:00.000Z",
+                            },
+                        ],
+                        start_time: 1620000000000,
+                        run_type: "llm",
+                        child_runs: [],
+                        extra: {},
+                        tags: [],
+                        dotted_order: `20210503T000000000001Z${chainRunId}.20210503T000000000002Z${toolRunId}.20210503T000000000003Z${llmRunId}`,
+                        trace_id: chainRunId,
+                    },
+                ],
+                end_time: 1620000000000,
+                execution_order: 2,
+                child_execution_order: 3,
+                outputs: { output: "output" },
+                serialized: { ...serialized, id: ["test_tool"] },
+                events: [
+                    {
+                        name: "start",
+                        time: "2021-05-03T00:00:00.000Z",
+                    },
+                    {
+                        name: "end",
+                        time: "2021-05-03T00:00:00.000Z",
+                    },
+                ],
+                start_time: 1620000000000,
+                inputs: { input: "test" },
+                run_type: "tool",
+                extra: {},
+                tags: [],
+                dotted_order: `20210503T000000000001Z${chainRunId}.20210503T000000000002Z${toolRunId}`,
+                trace_id: chainRunId,
+            },
+            {
+                id: llmRunId2,
+                name: "test_llm2",
+                parent_run_id: chainRunId,
+                end_time: 1620000000000,
+                execution_order: 4,
+                child_execution_order: 4,
+                inputs: { prompts: ["test"] },
+                outputs: {
+                    generations: [[]],
+                },
+                serialized: { ...serialized, id: ["test_llm2"] },
+                events: [
+                    {
+                        name: "start",
+                        time: "2021-05-03T00:00:00.000Z",
+                    },
+                    {
+                        name: "end",
+                        time: "2021-05-03T00:00:00.000Z",
+                    },
+                ],
+                start_time: 1620000000000,
+                run_type: "llm",
+                child_runs: [],
+                extra: {},
+                tags: [],
+                dotted_order: `20210503T000000000001Z${chainRunId}.20210503T000000000004Z${llmRunId2}`,
+                trace_id: chainRunId,
+            },
+        ],
+        id: chainRunId,
+        end_time: 1620000000000,
+        execution_order: 1,
+        child_execution_order: 4,
+        inputs: {
+            foo: "bar",
+        },
+        outputs: {
+            foo: "bar",
+        },
+        events: [
+            {
+                name: "start",
+                time: "2021-05-03T00:00:00.000Z",
+            },
+            {
+                name: "end",
+                time: "2021-05-03T00:00:00.000Z",
+            },
+        ],
+        name: "test",
+        serialized,
+        start_time: 1620000000000,
+        run_type: "chain",
+        extra: {},
+        tags: [],
+        parent_run_id: undefined,
+        dotted_order: `20210503T000000000001Z${chainRunId}`,
+        trace_id: chainRunId,
+    };
+    expect(tracer.runs.length).toBe(1);
+    expect(tracer.runs[0]).toEqual(compareRun);
+    const llmRunId3 = uuid.v4();
+    await tracer.handleLLMStart(serialized, ["test"], llmRunId3);
+    await tracer.handleLLMEnd({ generations: [[]] }, llmRunId3);
+    expect(tracer.runs.length).toBe(2);
+});

package/dist/utils/stream.cjs

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pipeGeneratorWithSetup = exports.AsyncGeneratorWithSetup = exports.concat = exports.atee = exports.IterableReadableStream = void 0;
+// Make this a type to override ReadableStream's async iterator type in case
+// the popular web-streams-polyfill is imported - the supplied types
+const index_js_1 = require("../singletons/index.cjs");
 /*
  * Support async iterator syntax for ReadableStreams in all environments.
  * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
@@ -167,7 +170,7 @@ function concat(first, second) {
 }
 exports.concat = concat;
 class AsyncGeneratorWithSetup {
-    constructor(generator, startSetup) {
+    constructor(params) {
         Object.defineProperty(this, "generator", {
             enumerable: true,
             configurable: true,
@@ -180,6 +183,12 @@ class AsyncGeneratorWithSetup {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "firstResult", {
             enumerable: true,
             configurable: true,
@@ -192,19 +201,23 @@ class AsyncGeneratorWithSetup {
             writable: true,
             value: false
         });
-        this.generator = generator;
+        this.generator = params.generator;
+        this.config = params.config;
         // setup is a promise that resolves only after the first iterator value
         // is available. this is useful when setup of several piped generators
         // needs to happen in logical order, ie. in the order in which input to
         // to each generator is available.
         this.setup = new Promise((resolve, reject) => {
-            this.firstResult = generator.next();
-            if (startSetup) {
-                this.firstResult.then(startSetup).then(resolve, reject);
-            }
-            else {
-                this.firstResult.then((_result) => resolve(undefined), reject);
-            }
+            const storage = index_js_1.AsyncLocalStorageProviderSingleton.getInstance();
+            void storage.run(params.config, async () => {
+                this.firstResult = params.generator.next();
+                if (params.startSetup) {
+                    this.firstResult.then(params.startSetup).then(resolve, reject);
+                }
+                else {
+                    this.firstResult.then((_result) => resolve(undefined), reject);
+                }
+            });
         });
     }
     async next(...args) {
@@ -212,7 +225,10 @@ class AsyncGeneratorWithSetup {
             this.firstResultUsed = true;
             return this.firstResult;
         }
-        return this.generator.next(...args);
+        const storage = index_js_1.AsyncLocalStorageProviderSingleton.getInstance();
+        return storage.run(this.config, async () => {
+            return this.generator.next(...args);
+        });
     }
     async return(value) {
         return this.generator.return(value);
@@ -226,7 +242,7 @@ class AsyncGeneratorWithSetup {
 }
 exports.AsyncGeneratorWithSetup = AsyncGeneratorWithSetup;
 async function pipeGeneratorWithSetup(to, generator, startSetup, ...args) {
-    const gen = new AsyncGeneratorWithSetup(generator, startSetup);
+    const gen = new AsyncGeneratorWithSetup({ generator, startSetup });
     const setup = await gen.setup;
     return { output: to(gen, setup, ...args), setup };
 }

package/dist/utils/stream.d.ts

@@ -14,9 +14,14 @@ export declare function concat<T extends Array<any> | string | number | Record<s
 export declare class AsyncGeneratorWithSetup<S = unknown, T = unknown, TReturn = unknown, TNext = unknown> implements AsyncGenerator<T, TReturn, TNext> {
     private generator;
     setup: Promise<S>;
+    config?: unknown;
     private firstResult;
     private firstResultUsed;
-    constructor(generator: AsyncGenerator<T>, startSetup?: () => Promise<S>);
+    constructor(params: {
+        generator: AsyncGenerator<T>;
+        startSetup?: () => Promise<S>;
+        config?: unknown;
+    });
     next(...args: [] | [TNext]): Promise<IteratorResult<T>>;
     return(value: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T>>;
     throw(e: Error): Promise<IteratorResult<T>>;

package/dist/utils/stream.js

@@ -1,3 +1,6 @@
+// Make this a type to override ReadableStream's async iterator type in case
+// the popular web-streams-polyfill is imported - the supplied types
+import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
 /*
  * Support async iterator syntax for ReadableStreams in all environments.
  * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
@@ -161,7 +164,7 @@ export function concat(first, second) {
     }
 }
 export class AsyncGeneratorWithSetup {
-    constructor(generator, startSetup) {
+    constructor(params) {
         Object.defineProperty(this, "generator", {
             enumerable: true,
             configurable: true,
@@ -174,6 +177,12 @@ export class AsyncGeneratorWithSetup {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "firstResult", {
             enumerable: true,
             configurable: true,
@@ -186,19 +195,23 @@ export class AsyncGeneratorWithSetup {
             writable: true,
             value: false
         });
-        this.generator = generator;
+        this.generator = params.generator;
+        this.config = params.config;
         // setup is a promise that resolves only after the first iterator value
         // is available. this is useful when setup of several piped generators
         // needs to happen in logical order, ie. in the order in which input to
         // to each generator is available.
         this.setup = new Promise((resolve, reject) => {
-            this.firstResult = generator.next();
-            if (startSetup) {
-                this.firstResult.then(startSetup).then(resolve, reject);
-            }
-            else {
-                this.firstResult.then((_result) => resolve(undefined), reject);
-            }
+            const storage = AsyncLocalStorageProviderSingleton.getInstance();
+            void storage.run(params.config, async () => {
+                this.firstResult = params.generator.next();
+                if (params.startSetup) {
+                    this.firstResult.then(params.startSetup).then(resolve, reject);
+                }
+                else {
+                    this.firstResult.then((_result) => resolve(undefined), reject);
+                }
+            });
         });
     }
     async next(...args) {
@@ -206,7 +219,10 @@ export class AsyncGeneratorWithSetup {
             this.firstResultUsed = true;
             return this.firstResult;
         }
-        return this.generator.next(...args);
+        const storage = AsyncLocalStorageProviderSingleton.getInstance();
+        return storage.run(this.config, async () => {
+            return this.generator.next(...args);
+        });
     }
     async return(value) {
         return this.generator.return(value);
@@ -219,7 +235,7 @@ export class AsyncGeneratorWithSetup {
     }
 }
 export async function pipeGeneratorWithSetup(to, generator, startSetup, ...args) {
-    const gen = new AsyncGeneratorWithSetup(generator, startSetup);
+    const gen = new AsyncGeneratorWithSetup({ generator, startSetup });
     const setup = await gen.setup;
     return { output: to(gen, setup, ...args), setup };
 }

package/dist/utils/testing/tests/chatfake.test.d.ts

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

package/dist/utils/testing/tests/chatfake.test.js

@@ -0,0 +1,112 @@
+import { describe, test, expect, jest } from "@jest/globals";
+import { HumanMessage } from "../../../messages/index.js";
+import { StringOutputParser } from "../../../output_parsers/string.js";
+import { FakeListChatModel } from "../index.js";
+describe("Test FakeListChatLLM", () => {
+    test("Should exist", async () => {
+        const chat = new FakeListChatModel({ responses: ["test response"] });
+        const message = new HumanMessage("test message");
+        const response = await chat.invoke([message]);
+        expect(typeof response.content).toBe("string");
+    });
+    test("Should return responses in order", async () => {
+        const chat = new FakeListChatModel({
+            responses: ["test response 1", "test response 2"],
+        });
+        const message = new HumanMessage("test message");
+        const response1 = await chat.invoke([message]);
+        const response2 = await chat.invoke([message]);
+        expect(response1.content).toBe("test response 1");
+        expect(response2.content).toBe("test response 2");
+    });
+    test("Should reset index when all responses have been returned", async () => {
+        const chat = new FakeListChatModel({
+            responses: ["test response 1", "test response 2"],
+        });
+        const message = new HumanMessage("test message");
+        const first_response = await chat.invoke([message]);
+        const second_response = await chat.invoke([message]);
+        const third_response = await chat.invoke([message]);
+        expect(first_response.content).toBe("test response 1");
+        expect(second_response.content).toBe("test response 2");
+        expect(third_response.content).toBe("test response 1");
+    });
+    test("Should return stop value as response when provided", async () => {
+        const chat = new FakeListChatModel({
+            responses: ["test response 1", "test response 2"],
+        });
+        const message = new HumanMessage("test message");
+        const response = await chat.invoke([message], { stop: ["stop"] });
+        expect(response.content).toBe("stop");
+    });
+    test("Should not increment index when stop value is provided", async () => {
+        const chat = new FakeListChatModel({
+            responses: ["test response 1", "test response 2"],
+        });
+        const message = new HumanMessage("test message");
+        const first_response = await chat.invoke([message], { stop: ["stop"] });
+        const second_response = await chat.invoke([message]);
+        expect(first_response.content).toBe("stop");
+        expect(second_response.content).toBe("test response 1");
+    });
+    test("Should return responses after sleep if requested", async () => {
+        const chat = new FakeListChatModel({
+            responses: ["test response 1", "test response 2"],
+            sleep: 10,
+        });
+        const sleepSpy = jest.spyOn(chat, "_sleep");
+        const message = new HumanMessage("test message");
+        await chat.invoke([message]);
+        expect(sleepSpy).toHaveBeenCalledTimes(1);
+    }, 30000);
+    test("Should stream responses if requested", async () => {
+        const chat = new FakeListChatModel({
+            responses: ["test response 1", "test response 2"],
+        });
+        const chunks = [];
+        const response = await chat
+            .pipe(new StringOutputParser())
+            .stream("Test message");
+        for await (const chunk of response) {
+            chunks.push(chunk);
+        }
+        expect(chunks.length).toBeGreaterThan(1);
+        expect(chunks.join("")).toBe("test response 1");
+    });
+    test("Should return responses in order when streaming", async () => {
+        const chat = new FakeListChatModel({
+            responses: ["test response 1", "test response 2"],
+        });
+        const chunks1 = [];
+        const chunks2 = [];
+        const response1 = await chat
+            .pipe(new StringOutputParser())
+            .stream("Test message");
+        for await (const chunk of response1) {
+            chunks1.push(chunk);
+        }
+        const response2 = await chat
+            .pipe(new StringOutputParser())
+            .stream("Test message");
+        for await (const chunk of response2) {
+            chunks2.push(chunk);
+        }
+        expect(chunks1.join("")).toBe("test response 1");
+        expect(chunks2.join("")).toBe("test response 2");
+    });
+    test("Should stream responses after sleep if requested", async () => {
+        const chat = new FakeListChatModel({
+            responses: ["test response 1", "test response 2"],
+            sleep: 10,
+        });
+        const sleepSpy = jest.spyOn(chat, "_sleep");
+        const chunks = [];
+        const response = await chat
+            .pipe(new StringOutputParser())
+            .stream("Test message");
+        for await (const chunk of response) {
+            chunks.push(chunk);
+        }
+        expect(sleepSpy).toHaveBeenCalledTimes(chunks.length);
+    }, 30000);
+});

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

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