@langchain/openai 0.0.32 → 0.0.34

package/dist/tests/chat_models_structured_output.int.test.js

@@ -1,232 +0,0 @@
-import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { ChatPromptTemplate } from "@langchain/core/prompts";
-import { ChatOpenAI } from "../chat_models.js";
-test("withStructuredOutput zod schema function calling", async () => {
-    const model = new ChatOpenAI({
-        temperature: 0,
-        modelName: "gpt-4-turbo-preview",
-    });
-    const calculatorSchema = z.object({
-        operation: z.enum(["add", "subtract", "multiply", "divide"]),
-        number1: z.number(),
-        number2: z.number(),
-    });
-    const modelWithStructuredOutput = model.withStructuredOutput(calculatorSchema, {
-        name: "calculator",
-    });
-    const prompt = ChatPromptTemplate.fromMessages([
-        "system",
-        "You are VERY bad at math and must always use a calculator.",
-        "human",
-        "Please help me!! What is 2 + 2?",
-    ]);
-    const chain = prompt.pipe(modelWithStructuredOutput);
-    const result = await chain.invoke({});
-    console.log(result);
-    expect("operation" in result).toBe(true);
-    expect("number1" in result).toBe(true);
-    expect("number2" in result).toBe(true);
-});
-test("withStructuredOutput zod schema JSON mode", async () => {
-    const model = new ChatOpenAI({
-        temperature: 0,
-        modelName: "gpt-4-turbo-preview",
-    });
-    const calculatorSchema = z.object({
-        operation: z.enum(["add", "subtract", "multiply", "divide"]),
-        number1: z.number(),
-        number2: z.number(),
-    });
-    const modelWithStructuredOutput = model.withStructuredOutput(calculatorSchema, {
-        name: "calculator",
-        method: "jsonMode",
-    });
-    const prompt = ChatPromptTemplate.fromMessages([
-        "system",
-        `You are VERY bad at math and must always use a calculator.
-Respond with a JSON object containing three keys:
-'operation': the type of operation to execute, either 'add', 'subtract', 'multiply' or 'divide',
-'number1': the first number to operate on,
-'number2': the second number to operate on.
-`,
-        "human",
-        "Please help me!! What is 2 + 2?",
-    ]);
-    const chain = prompt.pipe(modelWithStructuredOutput);
-    const result = await chain.invoke({});
-    console.log(result);
-    expect("operation" in result).toBe(true);
-    expect("number1" in result).toBe(true);
-    expect("number2" in result).toBe(true);
-});
-test("withStructuredOutput JSON schema function calling", async () => {
-    const model = new ChatOpenAI({
-        temperature: 0,
-        modelName: "gpt-4-turbo-preview",
-    });
-    const calculatorSchema = z.object({
-        operation: z.enum(["add", "subtract", "multiply", "divide"]),
-        number1: z.number(),
-        number2: z.number(),
-    });
-    const modelWithStructuredOutput = model.withStructuredOutput({
-        schema: zodToJsonSchema(calculatorSchema),
-        name: "calculator",
-    });
-    const prompt = ChatPromptTemplate.fromMessages([
-        "system",
-        `You are VERY bad at math and must always use a calculator.`,
-        "human",
-        "Please help me!! What is 2 + 2?",
-    ]);
-    const chain = prompt.pipe(modelWithStructuredOutput);
-    const result = await chain.invoke({});
-    console.log(result);
-    expect("operation" in result).toBe(true);
-    expect("number1" in result).toBe(true);
-    expect("number2" in result).toBe(true);
-});
-test("withStructuredOutput OpenAI function definition function calling", async () => {
-    const model = new ChatOpenAI({
-        temperature: 0,
-        modelName: "gpt-4-turbo-preview",
-    });
-    const calculatorSchema = z.object({
-        operation: z.enum(["add", "subtract", "multiply", "divide"]),
-        number1: z.number(),
-        number2: z.number(),
-    });
-    const modelWithStructuredOutput = model.withStructuredOutput({
-        name: "calculator",
-        parameters: zodToJsonSchema(calculatorSchema),
-    });
-    const prompt = ChatPromptTemplate.fromMessages([
-        "system",
-        `You are VERY bad at math and must always use a calculator.`,
-        "human",
-        "Please help me!! What is 2 + 2?",
-    ]);
-    const chain = prompt.pipe(modelWithStructuredOutput);
-    const result = await chain.invoke({});
-    console.log(result);
-    expect("operation" in result).toBe(true);
-    expect("number1" in result).toBe(true);
-    expect("number2" in result).toBe(true);
-});
-test("withStructuredOutput JSON schema JSON mode", async () => {
-    const model = new ChatOpenAI({
-        temperature: 0,
-        modelName: "gpt-4-turbo-preview",
-    });
-    const calculatorSchema = z.object({
-        operation: z.enum(["add", "subtract", "multiply", "divide"]),
-        number1: z.number(),
-        number2: z.number(),
-    });
-    const modelWithStructuredOutput = model.withStructuredOutput(zodToJsonSchema(calculatorSchema), {
-        name: "calculator",
-        method: "jsonMode",
-    });
-    const prompt = ChatPromptTemplate.fromMessages([
-        "system",
-        `You are VERY bad at math and must always use a calculator.
-Respond with a JSON object containing three keys:
-'operation': the type of operation to execute, either 'add', 'subtract', 'multiply' or 'divide',
-'number1': the first number to operate on,
-'number2': the second number to operate on.
-`,
-        "human",
-        "Please help me!! What is 2 + 2?",
-    ]);
-    const chain = prompt.pipe(modelWithStructuredOutput);
-    const result = await chain.invoke({});
-    console.log(result);
-    expect("operation" in result).toBe(true);
-    expect("number1" in result).toBe(true);
-    expect("number2" in result).toBe(true);
-});
-test("withStructuredOutput JSON schema", async () => {
-    const model = new ChatOpenAI({
-        temperature: 0,
-        modelName: "gpt-4-turbo-preview",
-    });
-    const jsonSchema = {
-        title: "calculator",
-        description: "A simple calculator",
-        type: "object",
-        properties: {
-            operation: {
-                type: "string",
-                enum: ["add", "subtract", "multiply", "divide"],
-            },
-            number1: { type: "number" },
-            number2: { type: "number" },
-        },
-    };
-    const modelWithStructuredOutput = model.withStructuredOutput(jsonSchema);
-    const prompt = ChatPromptTemplate.fromMessages([
-        "system",
-        `You are VERY bad at math and must always use a calculator.
-Respond with a JSON object containing three keys:
-'operation': the type of operation to execute, either 'add', 'subtract', 'multiply' or 'divide',
-'number1': the first number to operate on,
-'number2': the second number to operate on.
-`,
-        "human",
-        "Please help me!! What is 2 + 2?",
-    ]);
-    const chain = prompt.pipe(modelWithStructuredOutput);
-    const result = await chain.invoke({});
-    console.log(result);
-    expect("operation" in result).toBe(true);
-    expect("number1" in result).toBe(true);
-    expect("number2" in result).toBe(true);
-});
-test("withStructuredOutput includeRaw true", async () => {
-    const model = new ChatOpenAI({
-        temperature: 0,
-        modelName: "gpt-4-turbo-preview",
-    });
-    const calculatorSchema = z.object({
-        operation: z.enum(["add", "subtract", "multiply", "divide"]),
-        number1: z.number(),
-        number2: z.number(),
-    });
-    const modelWithStructuredOutput = model.withStructuredOutput(calculatorSchema, {
-        name: "calculator",
-        includeRaw: true,
-    });
-    const prompt = ChatPromptTemplate.fromMessages([
-        "system",
-        "You are VERY bad at math and must always use a calculator.",
-        "human",
-        "Please help me!! What is 2 + 2?",
-    ]);
-    const chain = prompt.pipe(modelWithStructuredOutput);
-    const result = await chain.invoke({});
-    console.log(result);
-    expect("parsed" in result).toBe(true);
-    // Need to make TS happy :)
-    if (!("parsed" in result)) {
-        throw new Error("parsed not in result");
-    }
-    const { parsed } = result;
-    expect("operation" in parsed).toBe(true);
-    expect("number1" in parsed).toBe(true);
-    expect("number2" in parsed).toBe(true);
-    expect("raw" in result).toBe(true);
-    // Need to make TS happy :)
-    if (!("raw" in result)) {
-        throw new Error("raw not in result");
-    }
-    const { raw } = result;
-    expect(raw.additional_kwargs.tool_calls?.length).toBeGreaterThan(0);
-    expect(raw.additional_kwargs.tool_calls?.[0].function.name).toBe("calculator");
-    expect("operation" in
-        JSON.parse(raw.additional_kwargs.tool_calls?.[0].function.arguments ?? "")).toBe(true);
-    expect("number1" in
-        JSON.parse(raw.additional_kwargs.tool_calls?.[0].function.arguments ?? "")).toBe(true);
-    expect("number2" in
-        JSON.parse(raw.additional_kwargs.tool_calls?.[0].function.arguments ?? "")).toBe(true);
-});

package/dist/tests/embeddings.int.test.d.ts

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

package/dist/tests/embeddings.int.test.js

@@ -1,84 +0,0 @@
-import { test, expect } from "@jest/globals";
-import { OpenAIEmbeddings } from "../embeddings.js";
-test("Test OpenAIEmbeddings.embedQuery", async () => {
-    const embeddings = new OpenAIEmbeddings();
-    const res = await embeddings.embedQuery("Hello world");
-    expect(typeof res[0]).toBe("number");
-});
-test("Test OpenAIEmbeddings.embedDocuments", async () => {
-    const embeddings = new OpenAIEmbeddings();
-    const res = await embeddings.embedDocuments(["Hello world", "Bye bye"]);
-    expect(res).toHaveLength(2);
-    expect(typeof res[0][0]).toBe("number");
-    expect(typeof res[1][0]).toBe("number");
-});
-test("Test OpenAIEmbeddings concurrency", async () => {
-    const embeddings = new OpenAIEmbeddings({
-        batchSize: 1,
-        maxConcurrency: 2,
-    });
-    const res = await embeddings.embedDocuments([
-        "Hello world",
-        "Bye bye",
-        "Hello world",
-        "Bye bye",
-        "Hello world",
-        "Bye bye",
-    ]);
-    expect(res).toHaveLength(6);
-    expect(res.find((embedding) => typeof embedding[0] !== "number")).toBe(undefined);
-});
-test("Test timeout error thrown from SDK", async () => {
-    await expect(async () => {
-        const model = new OpenAIEmbeddings({
-            timeout: 1,
-            maxRetries: 0,
-        });
-        await model.embedDocuments([
-            "Hello world",
-            "Bye bye",
-            "Hello world",
-            "Bye bye",
-            "Hello world",
-            "Bye bye",
-        ]);
-    }).rejects.toThrow();
-});
-test("Test OpenAI embeddings with an invalid org throws", async () => {
-    await expect(async () => {
-        const model = new OpenAIEmbeddings({
-            configuration: {
-                organization: "NOT_REAL",
-            },
-        });
-        await model.embedDocuments([
-            "Hello world",
-            "Bye bye",
-            "Hello world",
-            "Bye bye",
-            "Hello world",
-            "Bye bye",
-        ]);
-    }).rejects.toThrow();
-});
-test("Test OpenAIEmbeddings.embedQuery with v3 and dimensions", async () => {
-    const embeddings = new OpenAIEmbeddings({
-        modelName: "text-embedding-3-small",
-        dimensions: 127,
-    });
-    const res = await embeddings.embedQuery("Hello world");
-    expect(typeof res[0]).toBe("number");
-    expect(res.length).toBe(127);
-});
-test("Test OpenAIEmbeddings.embedDocuments with v3 and dimensions", async () => {
-    const embeddings = new OpenAIEmbeddings({
-        modelName: "text-embedding-3-small",
-        dimensions: 127,
-    });
-    const res = await embeddings.embedDocuments(["Hello world", "Bye bye"]);
-    expect(res).toHaveLength(2);
-    expect(typeof res[0][0]).toBe("number");
-    expect(typeof res[1][0]).toBe("number");
-    expect(res[0].length).toBe(127);
-    expect(res[1].length).toBe(127);
-});

package/dist/tests/legacy.int.test.d.ts

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

package/dist/tests/legacy.int.test.js

@@ -1,115 +0,0 @@
-import { expect, test } from "@jest/globals";
-import { CallbackManager } from "@langchain/core/callbacks/manager";
-import { OpenAIChat } from "../legacy.js";
-test("Test OpenAI", async () => {
-    const model = new OpenAIChat({ modelName: "gpt-3.5-turbo", maxTokens: 10 });
-    const res = await model.invoke("Print hello world");
-    console.log({ res });
-});
-test("Test OpenAI with prefix messages", async () => {
-    const model = new OpenAIChat({
-        prefixMessages: [
-            { role: "user", content: "My name is John" },
-            { role: "assistant", content: "Hi there" },
-        ],
-        maxTokens: 10,
-    });
-    const res = await model.invoke("What is my name");
-    console.log({ res });
-});
-test("Test OpenAI in streaming mode", async () => {
-    let nrNewTokens = 0;
-    let streamedCompletion = "";
-    const model = new OpenAIChat({
-        maxTokens: 10,
-        modelName: "gpt-3.5-turbo",
-        streaming: true,
-        callbackManager: CallbackManager.fromHandlers({
-            async handleLLMNewToken(token) {
-                nrNewTokens += 1;
-                streamedCompletion += token;
-            },
-        }),
-    });
-    const res = await model.invoke("Print hello world");
-    console.log({ res });
-    expect(nrNewTokens > 0).toBe(true);
-    expect(res).toBe(streamedCompletion);
-}, 30000);
-test("Test OpenAI with stop", async () => {
-    const model = new OpenAIChat({ maxTokens: 5 });
-    const res = await model.call("Print hello world", ["world"]);
-    console.log({ res });
-});
-test("Test OpenAI with stop in object", async () => {
-    const model = new OpenAIChat({ maxTokens: 5 });
-    const res = await model.invoke("Print hello world", { stop: ["world"] });
-    console.log({ res });
-});
-test("Test OpenAI with timeout in call options", async () => {
-    const model = new OpenAIChat({ maxTokens: 5 });
-    await expect(() => model.invoke("Print hello world", {
-        timeout: 10,
-    })).rejects.toThrow();
-}, 5000);
-test("Test OpenAI with timeout in call options and node adapter", async () => {
-    const model = new OpenAIChat({ maxTokens: 5 });
-    await expect(() => model.invoke("Print hello world", {
-        timeout: 10,
-    })).rejects.toThrow();
-}, 5000);
-test("Test OpenAI with signal in call options", async () => {
-    const model = new OpenAIChat({ maxTokens: 5 });
-    const controller = new AbortController();
-    await expect(() => {
-        const ret = model.invoke("Print hello world", {
-            signal: controller.signal,
-        });
-        controller.abort();
-        return ret;
-    }).rejects.toThrow();
-}, 5000);
-test("Test OpenAI with signal in call options and node adapter", async () => {
-    const model = new OpenAIChat({ maxTokens: 5 });
-    const controller = new AbortController();
-    await expect(() => {
-        const ret = model.invoke("Print hello world", {
-            signal: controller.signal,
-        });
-        controller.abort();
-        return ret;
-    }).rejects.toThrow();
-}, 5000);
-test("Test OpenAIChat stream method", async () => {
-    const model = new OpenAIChat({ maxTokens: 50, modelName: "gpt-3.5-turbo" });
-    const stream = await model.stream("Print hello world.");
-    const chunks = [];
-    for await (const chunk of stream) {
-        chunks.push(chunk);
-        console.log(chunks);
-    }
-    expect(chunks.length).toBeGreaterThan(1);
-});
-test("Test OpenAIChat stream method with abort", async () => {
-    await expect(async () => {
-        const model = new OpenAIChat({ maxTokens: 50, modelName: "gpt-3.5-turbo" });
-        const stream = await model.stream("How is your day going? Be extremely verbose.", {
-            signal: AbortSignal.timeout(1000),
-        });
-        for await (const chunk of stream) {
-            console.log(chunk);
-        }
-    }).rejects.toThrow();
-});
-test("Test OpenAIChat stream method with early break", async () => {
-    const model = new OpenAIChat({ maxTokens: 50, modelName: "gpt-3.5-turbo" });
-    const stream = await model.stream("How is your day going? Be extremely verbose.");
-    let i = 0;
-    for await (const chunk of stream) {
-        console.log(chunk);
-        i += 1;
-        if (i > 5) {
-            break;
-        }
-    }
-});

package/dist/tests/llms.int.test.d.ts

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