@langchain/core 0.2.18 → 0.2.19

package/dist/callbacks/tests/callbacks.test.js

@@ -1,495 +0,0 @@
-/* eslint-disable no-promise-executor-return */
-import { test, expect } from "@jest/globals";
-import * as uuid from "uuid";
-import { CallbackManager } from "../manager.js";
-import { BaseCallbackHandler } from "../base.js";
-import { Document } from "../../documents/document.js";
-import { HumanMessage } from "../../messages/index.js";
-class FakeCallbackHandler extends BaseCallbackHandler {
-    constructor(inputs) {
-        super(inputs);
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: `fake-${uuid.v4()}`
-        });
-        Object.defineProperty(this, "starts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "ends", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "errors", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "chainStarts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "chainEnds", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "llmStarts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "llmEnds", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "llmStreams", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "toolStarts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "toolEnds", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "agentEnds", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "retrieverStarts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "retrieverEnds", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "texts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-    }
-    async handleLLMStart(_llm, _prompts) {
-        this.starts += 1;
-        this.llmStarts += 1;
-    }
-    async handleLLMEnd(_output) {
-        this.ends += 1;
-        this.llmEnds += 1;
-    }
-    async handleLLMNewToken(_token) {
-        this.llmStreams += 1;
-    }
-    async handleLLMError(_err) {
-        this.errors += 1;
-    }
-    async handleChainStart(_chain, _inputs) {
-        this.starts += 1;
-        this.chainStarts += 1;
-    }
-    async handleChainEnd(_outputs) {
-        this.ends += 1;
-        this.chainEnds += 1;
-    }
-    async handleChainError(_err) {
-        this.errors += 1;
-    }
-    async handleToolStart(_tool, _input) {
-        this.starts += 1;
-        this.toolStarts += 1;
-    }
-    async handleToolEnd(_output) {
-        this.ends += 1;
-        this.toolEnds += 1;
-    }
-    async handleToolError(_err) {
-        this.errors += 1;
-    }
-    async handleText(_text) {
-        this.texts += 1;
-    }
-    async handleAgentAction(_action) {
-        this.starts += 1;
-        this.toolStarts += 1;
-    }
-    async handleAgentEnd(_action) {
-        this.ends += 1;
-        this.agentEnds += 1;
-    }
-    async handleRetrieverStart(_retriever, _query) {
-        this.starts += 1;
-        this.retrieverStarts += 1;
-    }
-    async handleRetrieverEnd(_documents) {
-        this.ends += 1;
-        this.retrieverEnds += 1;
-    }
-    async handleRetrieverError(_err) {
-        this.errors += 1;
-    }
-    copy() {
-        const newInstance = new FakeCallbackHandler();
-        newInstance.name = this.name;
-        newInstance.starts = this.starts;
-        newInstance.ends = this.ends;
-        newInstance.errors = this.errors;
-        newInstance.chainStarts = this.chainStarts;
-        newInstance.chainEnds = this.chainEnds;
-        newInstance.llmStarts = this.llmStarts;
-        newInstance.llmEnds = this.llmEnds;
-        newInstance.llmStreams = this.llmStreams;
-        newInstance.toolStarts = this.toolStarts;
-        newInstance.toolEnds = this.toolEnds;
-        newInstance.agentEnds = this.agentEnds;
-        newInstance.retrieverStarts = this.retrieverStarts;
-        newInstance.retrieverEnds = this.retrieverEnds;
-        newInstance.texts = this.texts;
-        return newInstance;
-    }
-}
-class FakeCallbackHandlerWithChatStart extends FakeCallbackHandler {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "chatModelStarts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-    }
-    async handleChatModelStart(_llm, _messages) {
-        this.starts += 1;
-        this.chatModelStarts += 1;
-    }
-}
-const serialized = {
-    lc: 1,
-    type: "constructor",
-    id: ["test"],
-    kwargs: {},
-};
-test("CallbackManager", async () => {
-    const manager = new CallbackManager();
-    const handler1 = new FakeCallbackHandler();
-    const handler2 = new FakeCallbackHandler();
-    manager.addHandler(handler1);
-    manager.addHandler(handler2);
-    const llmCbs = await manager.handleLLMStart(serialized, ["test"]);
-    await Promise.all(llmCbs.map(async (llmCb) => {
-        await llmCb.handleLLMEnd({ generations: [] });
-        await llmCb.handleLLMNewToken("test");
-        await llmCb.handleLLMError(new Error("test"));
-    }));
-    const chainCb = await manager.handleChainStart(serialized, { test: "test" });
-    await chainCb.handleChainEnd({ test: "test" });
-    await chainCb.handleChainError(new Error("test"));
-    const toolCb = await manager.handleToolStart(serialized, "test");
-    await toolCb.handleToolEnd("test");
-    await toolCb.handleToolError(new Error("test"));
-    await chainCb.handleText("test");
-    await chainCb.handleAgentAction({
-        tool: "test",
-        toolInput: "test",
-        log: "test",
-    });
-    await chainCb.handleAgentEnd({ returnValues: { test: "test" }, log: "test" });
-    const retrieverCb = await manager.handleRetrieverStart(serialized, "test");
-    await retrieverCb.handleRetrieverEnd([
-        new Document({ pageContent: "test", metadata: { test: "test" } }),
-    ]);
-    await retrieverCb.handleRetrieverError(new Error("test"));
-    // In case background mode is on while running this test
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    for (const handler of [handler1, handler2]) {
-        expect(handler.starts).toBe(5);
-        expect(handler.ends).toBe(5);
-        expect(handler.errors).toBe(4);
-        expect(handler.retrieverStarts).toBe(1);
-        expect(handler.retrieverEnds).toBe(1);
-        expect(handler.llmStarts).toBe(1);
-        expect(handler.llmEnds).toBe(1);
-        expect(handler.llmStreams).toBe(1);
-        expect(handler.chainStarts).toBe(1);
-        expect(handler.chainEnds).toBe(1);
-        expect(handler.toolStarts).toBe(2);
-        expect(handler.toolEnds).toBe(1);
-        expect(handler.agentEnds).toBe(1);
-        expect(handler.texts).toBe(1);
-    }
-});
-test("CallbackManager Chat Message Handling", async () => {
-    const manager = new CallbackManager();
-    const handler1 = new FakeCallbackHandler();
-    const handler2 = new FakeCallbackHandlerWithChatStart();
-    manager.addHandler(handler1);
-    manager.addHandler(handler2);
-    const llmCbs = await manager.handleChatModelStart(serialized, [
-        [new HumanMessage("test")],
-    ]);
-    await Promise.all(llmCbs.map(async (llmCb) => {
-        await llmCb.handleLLMEnd({ generations: [] });
-    }));
-    // Everything treated as llm in handler 1
-    expect(handler1.llmStarts).toBe(1);
-    expect(handler2.llmStarts).toBe(0);
-    expect(handler2.chatModelStarts).toBe(1);
-    // These should all be treated the same
-    for (const handler of [handler1, handler2]) {
-        expect(handler.starts).toBe(1);
-        expect(handler.ends).toBe(1);
-        expect(handler.errors).toBe(0);
-        expect(handler.llmEnds).toBe(1);
-    }
-});
-test("CallbackHandler with ignoreLLM", async () => {
-    const handler = new FakeCallbackHandler({
-        ignoreLLM: true,
-    });
-    const manager = new CallbackManager();
-    manager.addHandler(handler);
-    const llmCbs = await manager.handleLLMStart(serialized, ["test"]);
-    await Promise.all(llmCbs.map(async (llmCb) => {
-        await llmCb.handleLLMEnd({ generations: [] });
-        await llmCb.handleLLMNewToken("test");
-        await llmCb.handleLLMError(new Error("test"));
-    }));
-    expect(handler.starts).toBe(0);
-    expect(handler.ends).toBe(0);
-    expect(handler.errors).toBe(0);
-    expect(handler.llmStarts).toBe(0);
-    expect(handler.llmEnds).toBe(0);
-    expect(handler.llmStreams).toBe(0);
-});
-test("CallbackHandler with ignoreRetriever", async () => {
-    const handler = new FakeCallbackHandler({
-        ignoreRetriever: true,
-    });
-    const manager = new CallbackManager();
-    manager.addHandler(handler);
-    const retrieverCb = await manager.handleRetrieverStart(serialized, "test");
-    await retrieverCb.handleRetrieverEnd([
-        new Document({ pageContent: "test", metadata: { test: "test" } }),
-    ]);
-    await retrieverCb.handleRetrieverError(new Error("test"));
-    expect(handler.starts).toBe(0);
-    expect(handler.ends).toBe(0);
-    expect(handler.errors).toBe(0);
-    expect(handler.retrieverStarts).toBe(0);
-    expect(handler.retrieverEnds).toBe(0);
-});
-test("CallbackHandler with ignoreChain", async () => {
-    const handler = new FakeCallbackHandler({
-        ignoreChain: true,
-    });
-    const manager = new CallbackManager();
-    manager.addHandler(handler);
-    const chainCb = await manager.handleChainStart(serialized, { test: "test" });
-    await chainCb.handleChainEnd({ test: "test" });
-    await chainCb.handleChainError(new Error("test"));
-    expect(handler.starts).toBe(0);
-    expect(handler.ends).toBe(0);
-    expect(handler.errors).toBe(0);
-    expect(handler.chainStarts).toBe(0);
-    expect(handler.chainEnds).toBe(0);
-});
-test("CallbackHandler with ignoreAgent", async () => {
-    const handler = new FakeCallbackHandler({
-        ignoreAgent: true,
-    });
-    const manager = new CallbackManager();
-    manager.addHandler(handler);
-    const toolCb = await manager.handleToolStart(serialized, "test");
-    await toolCb.handleToolEnd("test");
-    await toolCb.handleToolError(new Error("test"));
-    const chainCb = await manager.handleChainStart(serialized, {});
-    await chainCb.handleAgentAction({
-        tool: "test",
-        toolInput: "test",
-        log: "test",
-    });
-    await chainCb.handleAgentEnd({ returnValues: { test: "test" }, log: "test" });
-    expect(handler.starts).toBe(1);
-    expect(handler.ends).toBe(0);
-    expect(handler.errors).toBe(0);
-    expect(handler.toolStarts).toBe(0);
-    expect(handler.toolEnds).toBe(0);
-    expect(handler.agentEnds).toBe(0);
-});
-test("CallbackManager with child manager", async () => {
-    const chainRunId = "chainRunId";
-    let llmWasCalled = false;
-    let chainWasCalled = false;
-    const manager = CallbackManager.fromHandlers({
-        async handleLLMStart(_llm, _prompts, _runId, parentRunId) {
-            expect(parentRunId).toBe(chainRunId);
-            llmWasCalled = true;
-        },
-        async handleChainStart(_chain, _inputs, runId, parentRunId) {
-            expect(runId).toBe(chainRunId);
-            expect(parentRunId).toBe(undefined);
-            chainWasCalled = true;
-        },
-    });
-    const chainCb = await manager.handleChainStart(serialized, { test: "test" }, chainRunId);
-    await chainCb.getChild().handleLLMStart(serialized, ["test"]);
-    expect(llmWasCalled).toBe(true);
-    expect(chainWasCalled).toBe(true);
-});
-test("CallbackManager with child manager inherited handlers", async () => {
-    const callbackManager1 = new CallbackManager();
-    const handler1 = new FakeCallbackHandler();
-    const handler2 = new FakeCallbackHandler();
-    const handler3 = new FakeCallbackHandler();
-    const handler4 = new FakeCallbackHandler();
-    callbackManager1.setHandlers([handler1, handler2]);
-    expect(callbackManager1.handlers).toEqual([handler1, handler2]);
-    expect(callbackManager1.inheritableHandlers).toEqual([handler1, handler2]);
-    const callbackManager2 = callbackManager1.copy([handler3, handler4]);
-    expect(callbackManager2.handlers).toEqual([
-        handler1,
-        handler2,
-        handler3,
-        handler4,
-    ]);
-    expect(callbackManager2.inheritableHandlers).toEqual([
-        handler1,
-        handler2,
-        handler3,
-        handler4,
-    ]);
-    const callbackManager3 = callbackManager1.copy([handler3, handler4], false);
-    expect(callbackManager3.handlers).toEqual([
-        handler1,
-        handler2,
-        handler3,
-        handler4,
-    ]);
-    expect(callbackManager3.inheritableHandlers).toEqual([handler1, handler2]);
-    const chainCb = await callbackManager3.handleChainStart(serialized, {
-        test: "test",
-    });
-    const childManager = chainCb.getChild();
-    expect(childManager.handlers.map((h) => h.name)).toEqual([
-        handler1.name,
-        handler2.name,
-    ]);
-    expect(childManager.inheritableHandlers.map((h) => h.name)).toEqual([
-        handler1.name,
-        handler2.name,
-    ]);
-    const toolCb = await childManager.handleToolStart(serialized, "test");
-    const childManager2 = toolCb.getChild();
-    expect(childManager2.handlers.map((h) => h.name)).toEqual([
-        handler1.name,
-        handler2.name,
-    ]);
-    expect(childManager2.inheritableHandlers.map((h) => h.name)).toEqual([
-        handler1.name,
-        handler2.name,
-    ]);
-});
-test("CallbackManager.copy()", () => {
-    const callbackManager1 = new CallbackManager();
-    const handler1 = new FakeCallbackHandler();
-    const handler2 = new FakeCallbackHandler();
-    const handler3 = new FakeCallbackHandler();
-    const handler4 = new FakeCallbackHandler();
-    callbackManager1.addHandler(handler1, true);
-    callbackManager1.addHandler(handler2, false);
-    callbackManager1.addTags(["a"], true);
-    callbackManager1.addTags(["b"], false);
-    callbackManager1.addMetadata({ a: "a" }, true);
-    callbackManager1.addMetadata({ b: "b" }, false);
-    expect(callbackManager1.handlers).toEqual([handler1, handler2]);
-    expect(callbackManager1.inheritableHandlers).toEqual([handler1]);
-    expect(callbackManager1.tags).toEqual(["a", "b"]);
-    expect(callbackManager1.inheritableTags).toEqual(["a"]);
-    expect(callbackManager1.metadata).toEqual({ a: "a", b: "b" });
-    expect(callbackManager1.inheritableMetadata).toEqual({ a: "a" });
-    const callbackManager2 = callbackManager1.copy([handler3]);
-    expect(callbackManager2.handlers.map((h) => h.name)).toEqual([
-        handler1.name,
-        handler2.name,
-        handler3.name,
-    ]);
-    expect(callbackManager2.inheritableHandlers.map((h) => h.name)).toEqual([
-        handler1.name,
-        handler3.name,
-    ]);
-    expect(callbackManager2.tags).toEqual(["a", "b"]);
-    expect(callbackManager2.inheritableTags).toEqual(["a"]);
-    const callbackManager3 = callbackManager2.copy([handler4], false);
-    expect(callbackManager3.handlers.map((h) => h.name)).toEqual([
-        handler1.name,
-        handler2.name,
-        handler3.name,
-        handler4.name,
-    ]);
-    expect(callbackManager3.inheritableHandlers.map((h) => h.name)).toEqual([
-        handler1.name,
-        handler3.name,
-    ]);
-});
-class FakeCallbackHandlerWithErrors extends FakeCallbackHandler {
-    constructor(input) {
-        super({ ...input, raiseError: true });
-    }
-    async handleChainStart(_chain, _inputs) {
-        throw Error("error!");
-    }
-    async handleLLMStart(_llm, _prompts) {
-        throw Error("llm start error!");
-    }
-}
-test("error handling in chain start", async () => {
-    const handler = new FakeCallbackHandlerWithErrors({
-        ignoreLLM: true,
-    });
-    const manager = new CallbackManager(undefined);
-    manager.addHandler(handler);
-    await expect(async () => {
-        await manager.handleChainStart(serialized, ["test"]);
-    }).rejects.toThrowError();
-    await manager.handleLLMStart(serialized, ["test"]);
-});
-test("error handling in llm start", async () => {
-    const handler = new FakeCallbackHandlerWithErrors({
-        ignoreChain: true,
-    });
-    const manager = new CallbackManager(undefined);
-    manager.addHandler(handler);
-    await manager.handleChainStart(serialized, ["test"]);
-    await expect(async () => {
-        await manager.handleLLMStart(serialized, ["test"]);
-    }).rejects.toThrowError();
-});

package/dist/callbacks/tests/manager.int.test.d.ts

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

package/dist/callbacks/tests/manager.int.test.js

@@ -1,29 +0,0 @@
-/* eslint-disable no-process-env */
-import { test } from "@jest/globals";
-import { PromptTemplate } from "../../prompts/prompt.js";
-import { FakeLLM } from "../../utils/testing/index.js";
-import { traceAsGroup, TraceGroup } from "../manager.js";
-import { StringOutputParser } from "../../output_parsers/string.js";
-test("Test grouping traces", async () => {
-    process.env.LANGCHAIN_TRACING_V2 = "true";
-    const chain = PromptTemplate.fromTemplate("hello world")
-        .pipe(new FakeLLM({}))
-        .pipe(new StringOutputParser());
-    const nextChain = PromptTemplate.fromTemplate("This is the day {input2}")
-        .pipe(new FakeLLM({}))
-        .pipe(new StringOutputParser());
-    const result = await traceAsGroup({ name: "my_chain_group" }, async (manager, arg1, { chain, nextChain }) => {
-        const result = await chain.invoke({ input: arg1 }, manager);
-        const nextResult = await nextChain.invoke({ input2: result }, manager);
-        return nextResult;
-    }, "I'm arg1", { chain, nextChain });
-    console.log(result);
-});
-test("Test TraceGroup object", async () => {
-    const traceGroup = new TraceGroup("my_trace_group");
-    const childManager = await traceGroup.start({ input: "Hello, World" });
-    const prompt = PromptTemplate.fromTemplate("Hello, world!");
-    const result = await prompt.invoke({}, { callbacks: childManager });
-    await traceGroup.end({ value: result.value });
-    expect(result.value).toBe("Hello, world!");
-});

package/dist/callbacks/tests/run_collector.test.d.ts

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

package/dist/callbacks/tests/run_collector.test.js

@@ -1,58 +0,0 @@
-import { v4 as uuidv4, validate } from "uuid";
-import { ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate, } from "../../prompts/chat.js";
-import { BaseLLM } from "../../language_models/llms.js";
-import { StringOutputParser } from "../../output_parsers/string.js";
-import { RunCollectorCallbackHandler } from "../../tracers/run_collector.js";
-class FakeLLM extends BaseLLM {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "nrMapCalls", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "nrReduceCalls", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-    }
-    _llmType() {
-        return "fake_1";
-    }
-    async _generate(_prompts) {
-        return {
-            generations: [
-                [
-                    {
-                        text: "Foo.",
-                    },
-                ],
-            ],
-        };
-    }
-}
-describe("RunCollectorCallbackHandler", () => {
-    it("should persist the given run object and set the reference_example_id to the exampleId", async () => {
-        // Create a chain that uses the dataset
-        const prompt = ChatPromptTemplate.fromMessages([
-            SystemMessagePromptTemplate.fromTemplate("You are in a rap battle."),
-            HumanMessagePromptTemplate.fromTemplate("Write the following {input}"),
-        ]);
-        const model = new FakeLLM({});
-        const chain = prompt.pipe(model).pipe(new StringOutputParser());
-        const exampleId = uuidv4();
-        const collector = new RunCollectorCallbackHandler({ exampleId });
-        await chain.invoke({ input: "foo" }, { callbacks: [collector] });
-        expect(collector.tracedRuns.length).toBe(1);
-        const tracedRun = collector.tracedRuns[0];
-        expect(tracedRun.id).toBeDefined();
-        if (tracedRun.id && validate(tracedRun.id)) {
-            expect(validate(tracedRun.id)).toBe(true);
-        }
-        expect(tracedRun.reference_example_id).toBe(exampleId);
-        expect(tracedRun?.child_runs?.length).toBe(3);
-    });
-});

package/dist/language_models/tests/chat_models.test.d.ts

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