@langchain/core 0.2.18-rc.0 → 0.2.19

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

@@ -1,378 +0,0 @@
-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/testing/tests/chatfake.test.d.ts

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

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

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

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

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

@@ -1,27 +0,0 @@
-import { test, expect, jest } from "@jest/globals";
-import { AsyncCaller } from "../async_caller.js";
-test("AsyncCaller passes on arguments and returns return value", async () => {
-    const caller = new AsyncCaller({});
-    const callable = jest.fn((arg1, arg2) => Promise.resolve([arg2, arg1]));
-    const resultDirect = await callable(1, 2);
-    const resultWrapped = await caller.call(callable, 1, 2);
-    expect(resultDirect).toEqual([2, 1]);
-    expect(resultWrapped).toEqual([2, 1]);
-});
-test("AsyncCaller retries on failure", async () => {
-    const caller = new AsyncCaller({});
-    // A direct call throws an error.
-    let callable = jest
-        .fn()
-        .mockRejectedValueOnce("error")
-        .mockResolvedValueOnce([2, 1]);
-    await expect(() => callable()).rejects.toEqual("error");
-    // A wrapped call retries and succeeds.
-    callable = jest
-        .fn()
-        .mockRejectedValueOnce("error")
-        .mockResolvedValueOnce([2, 1]);
-    const resultWrapped = await caller.call(callable);
-    expect(resultWrapped).toEqual([2, 1]);
-    expect(callable.mock.calls).toHaveLength(2);
-});

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

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

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

@@ -1,6 +0,0 @@
-import { getRuntimeEnvironment } from "../env.js";
-test("test getRuntimeEnvironment", async () => {
-    const runtimeEnvironment = await getRuntimeEnvironment();
-    console.log(runtimeEnvironment);
-    expect(runtimeEnvironment.runtime).toEqual("node");
-});

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

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

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

@@ -1,107 +0,0 @@
-import { z } from "zod";
-import { test, expect } from "@jest/globals";
-import { convertToOpenAIFunction, convertToOpenAITool, } from "../function_calling.js";
-import { FakeTool } from "../testing/index.js";
-test("Can convert tool to OpenAI Functions format", async () => {
-    const tool = new FakeTool({
-        name: "faketesttool",
-        description: "A fake test tool",
-        schema: z.object({
-            prop1: z.string(),
-            prop2: z.number().describe("Some desc"),
-            optionalProp: z.optional(z.array(z.object({
-                nestedRequired: z.string(),
-                nestedOptional: z.optional(z.string()),
-            }))),
-        }),
-    });
-    const result = convertToOpenAIFunction(tool);
-    expect(result).toEqual({
-        name: "faketesttool",
-        description: "A fake test tool",
-        parameters: {
-            type: "object",
-            properties: {
-                prop1: {
-                    type: "string",
-                },
-                prop2: {
-                    type: "number",
-                    description: "Some desc",
-                },
-                optionalProp: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        properties: {
-                            nestedRequired: {
-                                type: "string",
-                            },
-                            nestedOptional: {
-                                type: "string",
-                            },
-                        },
-                        required: ["nestedRequired"],
-                        additionalProperties: false,
-                    },
-                },
-            },
-            required: ["prop1", "prop2"],
-            additionalProperties: false,
-            $schema: "http://json-schema.org/draft-07/schema#",
-        },
-    });
-});
-test("Can convert tool to OpenAI Tool format", async () => {
-    const tool = new FakeTool({
-        name: "faketesttool",
-        description: "A fake test tool",
-        schema: z.object({
-            prop1: z.string(),
-            prop2: z.number().describe("Some desc"),
-            optionalProp: z.optional(z.array(z.object({
-                nestedRequired: z.string(),
-                nestedOptional: z.optional(z.string()),
-            }))),
-        }),
-    });
-    const result = convertToOpenAITool(tool);
-    expect(result).toEqual({
-        type: "function",
-        function: {
-            name: "faketesttool",
-            description: "A fake test tool",
-            parameters: {
-                type: "object",
-                properties: {
-                    prop1: {
-                        type: "string",
-                    },
-                    prop2: {
-                        type: "number",
-                        description: "Some desc",
-                    },
-                    optionalProp: {
-                        type: "array",
-                        items: {
-                            type: "object",
-                            properties: {
-                                nestedRequired: {
-                                    type: "string",
-                                },
-                                nestedOptional: {
-                                    type: "string",
-                                },
-                            },
-                            required: ["nestedRequired"],
-                            additionalProperties: false,
-                        },
-                    },
-                },
-                required: ["prop1", "prop2"],
-                additionalProperties: false,
-                $schema: "http://json-schema.org/draft-07/schema#",
-            },
-        },
-    });
-});

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

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