@langchain/core 0.2.18 → 0.2.19

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

@@ -1,238 +0,0 @@
-/* eslint-disable no-promise-executor-return */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { StringOutputParser } from "../../output_parsers/string.js";
-import { ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate, } from "../../prompts/chat.js";
-import { concat } from "../../utils/stream.js";
-import { FakeLLM, FakeChatModel, FakeRetriever, FakeStreamingLLM, } from "../../utils/testing/index.js";
-import { RunnableSequence, RunnableMap } from "../base.js";
-import { RunnablePassthrough } from "../passthrough.js";
-test("Create a runnable sequence with a runnable map", 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 inputs = {
-        question: (input) => input,
-        documents: RunnableSequence.from([
-            new FakeRetriever(),
-            (docs) => JSON.stringify(docs),
-        ]),
-        extraField: new FakeLLM({}),
-    };
-    const runnable = new RunnableMap({ steps: inputs })
-        .pipe(promptTemplate)
-        .pipe(llm);
-    const result = await runnable.invoke("Do you know the Muffin Man?");
-    console.log(result);
-    expect(result.content).toEqual(`You are a nice assistant.\nContext:\n[{"pageContent":"foo","metadata":{}},{"pageContent":"bar","metadata":{}}]\n\nQuestion:\nDo you know the Muffin Man?`);
-});
-test("Test map inference in a sequence", async () => {
-    const prompt = ChatPromptTemplate.fromTemplate("context: {context}, question: {question}");
-    const chain = RunnableSequence.from([
-        {
-            question: new RunnablePassthrough(),
-            context: async () => "SOME STUFF",
-        },
-        prompt,
-        new FakeLLM({}),
-        new StringOutputParser(),
-    ]);
-    const response = await chain.invoke("Just passing through.");
-    console.log(response);
-    expect(response).toBe(`Human: context: SOME STUFF, question: Just passing through.`);
-});
-test("Should not allow mismatched inputs", async () => {
-    const prompt = ChatPromptTemplate.fromTemplate("context: {context}, question: {question}");
-    const badChain = RunnableSequence.from([
-        {
-            // @ts-expect-error TS compiler should flag mismatched input types
-            question: new FakeLLM({}),
-            context: async (input) => input,
-        },
-        prompt,
-        new FakeLLM({}),
-        new StringOutputParser(),
-    ]);
-    console.log(badChain);
-});
-test("Should not allow improper inputs into a map in a sequence", async () => {
-    const prompt = ChatPromptTemplate.fromTemplate("context: {context}, question: {question}");
-    const map = RunnableMap.from({
-        question: new FakeLLM({}),
-        context: async (_input) => 9,
-    });
-    // @ts-expect-error TS compiler should flag mismatched output types
-    const runnable = prompt.pipe(map);
-    console.log(runnable);
-});
-test("Should not allow improper outputs from a map into the next item in a sequence", async () => {
-    const map = RunnableMap.from({
-        question: new FakeLLM({}),
-        context: async (_input) => 9,
-    });
-    // @ts-expect-error TS compiler should flag mismatched output types
-    const runnable = map.pipe(new FakeLLM({}));
-    console.log(runnable);
-});
-test("Should stream chunks from each step as they are produced", async () => {
-    const prompt = ChatPromptTemplate.fromMessages([
-        ["system", "You are a nice assistant."],
-        "{question}",
-    ]);
-    const chat = new FakeChatModel({});
-    const llm = new FakeStreamingLLM({ sleep: 0 });
-    const chain = RunnableSequence.from([
-        prompt,
-        RunnableMap.from({
-            passthrough: new RunnablePassthrough(),
-            chat,
-            llm,
-        }),
-    ]);
-    const stream = await chain.stream({ question: "What is your name?" });
-    const chunks = [];
-    for await (const chunk of stream) {
-        chunks.push(chunk);
-    }
-    expect(chunks.length).toBeGreaterThan(3);
-    expect(chunks.reduce(concat)).toEqual(await chain.invoke({ question: "What is your name?" }));
-    const chainWithSelect = chain.pipe((output) => output.llm);
-    expect(await chainWithSelect.invoke({ question: "What is your name?" }))
-        .toEqual(`System: You are a nice assistant.
-Human: What is your name?`);
-});
-test("Should stream chunks through runnable passthrough and assign", async () => {
-    const llm = new FakeStreamingLLM({ sleep: 0 });
-    const chain = RunnableSequence.from([
-        llm,
-        RunnableMap.from({
-            llm: new RunnablePassthrough(),
-        }),
-    ]);
-    const stream = await chain.stream("What is your name?");
-    const chunks = [];
-    for await (const chunk of stream) {
-        chunks.push(chunk);
-    }
-    expect(chunks).toEqual([
-        { llm: "W" },
-        { llm: "h" },
-        { llm: "a" },
-        { llm: "t" },
-        { llm: " " },
-        { llm: "i" },
-        { llm: "s" },
-        { llm: " " },
-        { llm: "y" },
-        { llm: "o" },
-        { llm: "u" },
-        { llm: "r" },
-        { llm: " " },
-        { llm: "n" },
-        { llm: "a" },
-        { llm: "m" },
-        { llm: "e" },
-        { llm: "?" },
-    ]);
-    expect(chunks.reduce(concat)).toEqual(await chain.invoke("What is your name?"));
-    const chainWithAssign = chain.pipe(RunnablePassthrough.assign({
-        chat: RunnableSequence.from([(input) => input.llm, llm]),
-    }));
-    const stream2 = await chainWithAssign.stream("What is your name?");
-    const chunks2 = [];
-    for await (const chunk of stream2) {
-        chunks2.push(chunk);
-    }
-    expect(chunks2).toEqual([
-        { llm: "W" },
-        { llm: "h" },
-        { llm: "a" },
-        { llm: "t" },
-        { llm: " " },
-        { llm: "i" },
-        { llm: "s" },
-        { llm: " " },
-        { llm: "y" },
-        { llm: "o" },
-        { llm: "u" },
-        { llm: "r" },
-        { llm: " " },
-        { llm: "n" },
-        { llm: "a" },
-        { llm: "m" },
-        { llm: "e" },
-        { llm: "?" },
-        { chat: "W" },
-        { chat: "h" },
-        { chat: "a" },
-        { chat: "t" },
-        { chat: " " },
-        { chat: "i" },
-        { chat: "s" },
-        { chat: " " },
-        { chat: "y" },
-        { chat: "o" },
-        { chat: "u" },
-        { chat: "r" },
-        { chat: " " },
-        { chat: "n" },
-        { chat: "a" },
-        { chat: "m" },
-        { chat: "e" },
-        { chat: "?" },
-    ]);
-    expect(chunks2.reduce(concat)).toEqual(await chainWithAssign.invoke("What is your name?"));
-    const chainWithPick = chainWithAssign.pick("llm");
-    const chunks3 = [];
-    for await (const chunk of await chainWithPick.stream("What is your name?")) {
-        chunks3.push(chunk);
-    }
-    expect(chunks3).toEqual([
-        "W",
-        "h",
-        "a",
-        "t",
-        " ",
-        "i",
-        "s",
-        " ",
-        "y",
-        "o",
-        "u",
-        "r",
-        " ",
-        "n",
-        "a",
-        "m",
-        "e",
-        "?",
-    ]);
-    expect(chunks3.reduce(concat)).toEqual(await chainWithPick.invoke("What is your name?"));
-    const chainWithPickMulti = chainWithAssign.pick(["llm"]);
-    const chunks4 = [];
-    for await (const chunk of await chainWithPickMulti.stream("What is your name?")) {
-        chunks4.push(chunk);
-    }
-    expect(chunks4).toEqual([
-        { llm: "W" },
-        { llm: "h" },
-        { llm: "a" },
-        { llm: "t" },
-        { llm: " " },
-        { llm: "i" },
-        { llm: "s" },
-        { llm: " " },
-        { llm: "y" },
-        { llm: "o" },
-        { llm: "u" },
-        { llm: "r" },
-        { llm: " " },
-        { llm: "n" },
-        { llm: "a" },
-        { llm: "m" },
-        { llm: "e" },
-        { llm: "?" },
-    ]);
-    expect(chunks4.reduce(concat)).toEqual(await chainWithPickMulti.invoke("What is your name?"));
-});

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

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

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

@@ -1,96 +0,0 @@
-import { PromptTemplate } from "../../prompts/prompt.js";
-import { FakeChatModel } from "../../utils/testing/index.js";
-import { RunnablePassthrough } from "../passthrough.js";
-import { JsonOutputParser } from "../../output_parsers/json.js";
-import { RunnableSequence } from "../base.js";
-test("RunnablePassthrough can call .assign and pass prev result through", async () => {
-    const promptTemplate = PromptTemplate.fromTemplate("{input}");
-    const llm = new FakeChatModel({});
-    const parser = new JsonOutputParser();
-    const text = `\`\`\`
-{"outputValue": "testing"}
-\`\`\``;
-    const chain = promptTemplate.pipe(llm).pipe(parser);
-    const chainWithAssign = chain.pipe(RunnablePassthrough.assign({
-        outputValue: (i) => i.outputValue,
-    }));
-    const result = await chainWithAssign.invoke({ input: text });
-    console.log(result);
-    expect(result).toEqual({ outputValue: "testing" });
-});
-test("RunnablePassthrough can call .assign as the first step with proper typing", async () => {
-    const promptTemplate = PromptTemplate.fromTemplate("{input}");
-    const llm = new FakeChatModel({});
-    const parser = new JsonOutputParser();
-    const text = `\`\`\`
-{"outputValue": "testing2"}
-\`\`\``;
-    const chain = RunnableSequence.from([
-        RunnablePassthrough.assign({
-            input: (input) => input.otherProp,
-        }),
-        promptTemplate,
-        llm,
-        parser,
-    ]);
-    const result = await chain.invoke({ otherProp: text });
-    console.log(result);
-    expect(result).toEqual({ outputValue: "testing2" });
-});
-test("RunnablePassthrough can invoke a function without modifying passthrough value", async () => {
-    let wasCalled = false;
-    const addOne = (input) => {
-        wasCalled = true;
-        return input + 1;
-    };
-    const passthrough = new RunnablePassthrough({
-        func: addOne,
-    });
-    const result = await passthrough.invoke(1);
-    expect(result).toEqual(1);
-    expect(wasCalled).toEqual(true);
-});
-test("RunnablePassthrough can transform a function as constructor args", async () => {
-    let wasCalled = false;
-    const addOne = (input) => {
-        wasCalled = true;
-        return input + 1;
-    };
-    const passthrough = new RunnablePassthrough({
-        func: addOne,
-    });
-    async function* generateNumbers() {
-        yield 1;
-    }
-    const transformedGenerator = passthrough.transform(generateNumbers(), {});
-    const results = [];
-    for await (const value of transformedGenerator) {
-        results.push(value);
-    }
-    expect(results).toEqual([1]);
-    expect(wasCalled).toEqual(true);
-});
-test("RunnablePassthrough can invoke a function and pass through config", async () => {
-    let wasCalled = false;
-    let addOneResult = 0;
-    const addOne = (input, config) => {
-        wasCalled = true;
-        if (!config?.configurable?.number ??
-            Number.isNaN(config?.configurable?.number)) {
-            throw new Error("configurable.number is NaN");
-        }
-        console.log(config.configurable.number);
-        addOneResult = input + config.configurable.number;
-    };
-    const passthrough = new RunnablePassthrough({
-        func: addOne,
-    });
-    const result = await passthrough.invoke(1, {
-        configurable: {
-            number: 1,
-        },
-    });
-    expect(result).toEqual(1);
-    expect(addOneResult).toEqual(2);
-    expect(wasCalled).toEqual(true);
-});

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

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

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

@@ -1,138 +0,0 @@
-import { HumanMessage } from "../../messages/index.js";
-import { applyPatch } from "../../utils/json_patch.js";
-import { RemoteRunnable } from "../remote.js";
-test("invoke hosted langserve", async () => {
-    const remote = new RemoteRunnable({
-        url: `https://chat-langchain-backend.langchain.dev/chat`,
-    });
-    const result = await remote.invoke({
-        question: "What is a document loader?",
-    });
-    console.log(result);
-});
-test("invoke hosted langserve error handling", async () => {
-    const remote = new RemoteRunnable({
-        url: `https://chat-langchain-backend.langchain.dev/nonexistent`,
-    });
-    await expect(async () => {
-        await remote.invoke({
-            question: "What is a document loader?",
-        });
-    }).rejects.toThrowError();
-});
-test("stream hosted langserve", async () => {
-    const remote = new RemoteRunnable({
-        url: `https://chat-langchain-backend.langchain.dev/chat`,
-    });
-    const result = await remote.stream({
-        question: "What is a document loader?",
-    });
-    let totalByteSize = 0;
-    for await (const chunk of result) {
-        console.log(chunk);
-        const jsonString = JSON.stringify(chunk);
-        const byteSize = Buffer.byteLength(jsonString, "utf-8");
-        totalByteSize += byteSize;
-    }
-    console.log("totalByteSize", totalByteSize);
-});
-test("stream error handling hosted langserve", async () => {
-    const remote = new RemoteRunnable({
-        url: `https://chat-langchain-backend.langchain.dev/nonexistent`,
-    });
-    await expect(async () => {
-        const result = await remote.stream({
-            question: "What is a document loader?",
-        });
-        for await (const chunk of result) {
-            console.log(chunk);
-        }
-    }).rejects.toThrowError();
-});
-test("streamLog hosted langserve", async () => {
-    const remote = new RemoteRunnable({
-        url: `https://chat-langchain-backend.langchain.dev/chat`,
-    });
-    const result = await remote.streamLog({
-        question: "What is a document loader?",
-    });
-    let totalByteSize = 0;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let aggregate = {};
-    for await (const chunk of result) {
-        const jsonString = JSON.stringify(chunk);
-        aggregate = applyPatch(aggregate, chunk.ops).newDocument;
-        const byteSize = Buffer.byteLength(jsonString, "utf-8");
-        totalByteSize += byteSize;
-    }
-    console.log("aggregate", aggregate);
-    console.log("totalByteSize", totalByteSize);
-});
-test("streamLog error handling hosted langserve", async () => {
-    const remote = new RemoteRunnable({
-        url: `https://chat-langchain-backend.langchain.dev/nonexistent`,
-    });
-    const result = await remote.streamLog({
-        question: "What is a document loader?",
-    });
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    await expect(async () => {
-        for await (const chunk of result) {
-            console.log(chunk);
-        }
-    }).rejects.toThrowError();
-});
-test("streamLog hosted langserve with concat syntax", async () => {
-    const remote = new RemoteRunnable({
-        url: `https://chat-langchain-backend.langchain.dev/chat`,
-    });
-    const result = await remote.streamLog({
-        question: "What is a document loader?",
-    });
-    let totalByteSize = 0;
-    let state;
-    for await (const chunk of result) {
-        if (!state) {
-            state = chunk;
-        }
-        else {
-            state = state.concat(chunk);
-        }
-        const jsonString = JSON.stringify(chunk);
-        const byteSize = Buffer.byteLength(jsonString, "utf-8");
-        totalByteSize += byteSize;
-    }
-    console.log("final state", state);
-    console.log("totalByteSize", totalByteSize);
-});
-test.skip("stream events hosted langserve with concat syntax", async () => {
-    const remote = new RemoteRunnable({
-        url: `https://privateurl.com/pirate-speak/`,
-    });
-    const result = await remote.streamEvents({
-        input: "What is a document loader?",
-        chat_history: [new HumanMessage("What is a document loader?")],
-    }, { version: "v1" });
-    let totalByteSize = 0;
-    const state = [];
-    for await (const chunk of result) {
-        console.log(chunk);
-        state.push(chunk);
-        const jsonString = JSON.stringify(chunk);
-        const byteSize = Buffer.byteLength(jsonString, "utf-8");
-        totalByteSize += byteSize;
-    }
-    // console.log("final state", state);
-    console.log("totalByteSize", totalByteSize);
-});
-test.skip("streamLog with raw messages", async () => {
-    const chain = new RemoteRunnable({
-        url: "https://aimor-deployment-bf1e4ebc87365334b3b8a6b175fb4151-ffoprvkqsa-uc.a.run.app/",
-    });
-    const events = chain.streamLog([new HumanMessage("I'd like some advice!")], {
-        configurable: { thread_id: "THREAD_ID", user_id: "USER_ID" },
-    });
-    for await (const logEvent of events) {
-        console.log(logEvent);
-    }
-});

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

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

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

@@ -1,200 +0,0 @@
-/* eslint-disable no-promise-executor-return */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { jest, test } from "@jest/globals";
-import { AIMessage, HumanMessage, SystemMessage, } from "../../messages/index.js";
-import { RemoteRunnable } from "../remote.js";
-import { ChatPromptValue } from "../../prompt_values.js";
-import { PromptTemplate } from "../../prompts/prompt.js";
-const BASE_URL = "http://my-langserve-endpoint";
-function respToStream(resp) {
-    const chunks = resp.split("\n");
-    return new ReadableStream({
-        start(controller) {
-            for (const chunk of chunks) {
-                controller.enqueue(Buffer.from(`${chunk}\n`));
-            }
-            controller.close();
-        },
-    });
-}
-const aResp = `event: data
-data: ["a", "b", "c", "d"]
-
-event: end`;
-const bResp = `event: data
-data: {"content": "", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": "\\"", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": "object", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": "1", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": ",", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": " object", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": "2", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": ",", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": " object", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": "3", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": ",", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": " object", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": "4", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": ",", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": " object", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": "5", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": "\\"", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: data
-data: {"content": "", "additional_kwargs": {}, "type": "AIMessageChunk", "example": false}
-
-event: end`;
-const strangeTypesResp = `event: data
-data: {"content": "what is a document loader", "additional_kwargs": {}, "type": "human", "example": false}
-
-event: data
-data: {"messages":[{"content":"You are an expert programmer and problem-solver, tasked with answering any question about Langchain.","type":"system","additional_kwargs":{}},{"content":"I am an AI","type":"ai","additional_kwargs":{}}]}
-
-event: end`;
-describe("RemoteRunnable", () => {
-    beforeEach(() => {
-        // mock langserve service
-        const returnDataByEndpoint = {
-            "/a/invoke": JSON.stringify({ output: ["a", "b", "c"] }),
-            "/a/batch": JSON.stringify({
-                output: [
-                    ["a", "b", "c"],
-                    ["d", "e", "f"],
-                ],
-            }),
-            "/a/stream": respToStream(aResp),
-            "/b/stream": respToStream(bResp),
-            "/strange_types/stream": respToStream(strangeTypesResp),
-        };
-        const oldFetch = global.fetch;
-        global.fetch = jest
-            .fn()
-            .mockImplementation(async (url, init) => {
-            if (!url.startsWith(BASE_URL))
-                return await oldFetch(url, init);
-            const { pathname } = new URL(url);
-            const resp = new Response(returnDataByEndpoint[pathname]);
-            return resp;
-        });
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    test("Invoke local langserve", async () => {
-        // mock fetch, expect /invoke
-        const remote = new RemoteRunnable({ url: `${BASE_URL}/a` });
-        const result = await remote.invoke({ text: "string" });
-        expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/a/invoke`, expect.objectContaining({
-            body: '{"input":{"text":"string"},"config":{"tags":[],"metadata":{},"recursionLimit":25},"kwargs":{}}',
-        }));
-        expect(result).toEqual(["a", "b", "c"]);
-    });
-    test("Invoke local langserve passing a configurable object", async () => {
-        // mock fetch, expect /invoke
-        const remote = new RemoteRunnable({ url: `${BASE_URL}/a` });
-        const result = await remote.invoke({ text: "string" }, {
-            configurable: {
-                destination: "destination",
-                integration_id: "integration_id",
-                user_id: "user_id",
-            },
-        });
-        expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/a/invoke`, expect.objectContaining({
-            body: expect.any(String),
-        }));
-        expect(result).toEqual(["a", "b", "c"]);
-    });
-    test("Batch local langserve", async () => {
-        const returnData = [
-            ["a", "b", "c"],
-            ["d", "e", "f"],
-        ];
-        const remote = new RemoteRunnable({ url: `${BASE_URL}/a` });
-        const result = await remote.batch([{ text: "1" }, { text: "2" }]);
-        expect(result).toEqual(returnData);
-    });
-    test("Stream local langserve", async () => {
-        const remote = new RemoteRunnable({ url: `${BASE_URL}/a` });
-        const stream = await remote.stream({ text: "What are the 5 best apples?" });
-        let chunkCount = 0;
-        for await (const chunk of stream) {
-            expect(chunk).toEqual(["a", "b", "c", "d"]);
-            chunkCount += 1;
-        }
-        expect(chunkCount).toBe(1);
-    });
-    test("Stream model output", async () => {
-        const remote = new RemoteRunnable({ url: `${BASE_URL}/b` });
-        const stream = await remote.stream({ text: "What are the 5 best apples?" });
-        let chunkCount = 0;
-        let accumulator = null;
-        for await (const chunk of stream) {
-            const innerChunk = chunk;
-            accumulator = accumulator ? accumulator.concat(innerChunk) : innerChunk;
-            chunkCount += 1;
-        }
-        expect(chunkCount).toBe(18);
-        expect(accumulator?.content).toEqual('"object1, object2, object3, object4, object5"');
-    });
-    test("Stream legacy data type formats", async () => {
-        const remote = new RemoteRunnable({ url: `${BASE_URL}/strange_types` });
-        const stream = await remote.stream({ text: "What are the 5 best apples?" });
-        const chunks = [];
-        for await (const chunk of stream) {
-            console.log(chunk);
-            chunks.push(chunk);
-        }
-        expect(chunks[0]).toBeInstanceOf(HumanMessage);
-        expect(chunks[1]).toBeInstanceOf(ChatPromptValue);
-        expect(chunks[1].messages[0]).toBeInstanceOf(SystemMessage);
-        expect(chunks[1].messages[1]).toBeInstanceOf(AIMessage);
-    });
-    test("Streaming in a chain with model output", async () => {
-        const remote = new RemoteRunnable({ url: `${BASE_URL}/b` });
-        const prompt = PromptTemplate.fromTemplate("");
-        const chunks = await prompt
-            .pipe(remote)
-            .stream({ text: "What are the 5 best apples?" });
-        let chunkCount = 0;
-        let accumulator = null;
-        for await (const chunk of chunks) {
-            const innerChunk = chunk;
-            accumulator = accumulator ? accumulator.concat(innerChunk) : innerChunk;
-            chunkCount += 1;
-        }
-        expect(chunkCount).toBe(18);
-        expect(accumulator?.content).toEqual('"object1, object2, object3, object4, object5"');
-    });
-});

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

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