@langchain/openai 0.0.0

package/dist/utils/azure.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEndpoint = void 0;
+/**
+ * This function generates an endpoint URL for (Azure) OpenAI
+ * based on the configuration parameters provided.
+ *
+ * @param {OpenAIEndpointConfig} config - The configuration object for the (Azure) endpoint.
+ *
+ * @property {string} config.azureOpenAIApiDeploymentName - The deployment name of Azure OpenAI.
+ * @property {string} config.azureOpenAIApiInstanceName - The instance name of Azure OpenAI.
+ * @property {string} config.azureOpenAIApiKey - The API Key for Azure OpenAI.
+ * @property {string} config.azureOpenAIBasePath - The base path for Azure OpenAI.
+ * @property {string} config.baseURL - Some other custom base path URL.
+ *
+ * The function operates as follows:
+ * - If both `azureOpenAIBasePath` and `azureOpenAIApiDeploymentName` (plus `azureOpenAIApiKey`) are provided, it returns an URL combining these two parameters (`${azureOpenAIBasePath}/${azureOpenAIApiDeploymentName}`).
+ * - If `azureOpenAIApiKey` is provided, it checks for `azureOpenAIApiInstanceName` and `azureOpenAIApiDeploymentName` and throws an error if any of these is missing. If both are provided, it generates an URL incorporating these parameters.
+ * - If none of the above conditions are met, return any custom `baseURL`.
+ * - The function returns the generated URL as a string, or undefined if no custom paths are specified.
+ *
+ * @throws Will throw an error if the necessary parameters for generating the URL are missing.
+ *
+ * @returns {string | undefined} The generated (Azure) OpenAI endpoint URL.
+ */
+function getEndpoint(config) {
+    const { azureOpenAIApiDeploymentName, azureOpenAIApiInstanceName, azureOpenAIApiKey, azureOpenAIBasePath, baseURL, } = config;
+    if (azureOpenAIApiKey &&
+        azureOpenAIBasePath &&
+        azureOpenAIApiDeploymentName) {
+        return `${azureOpenAIBasePath}/${azureOpenAIApiDeploymentName}`;
+    }
+    if (azureOpenAIApiKey) {
+        if (!azureOpenAIApiInstanceName) {
+            throw new Error("azureOpenAIApiInstanceName is required when using azureOpenAIApiKey");
+        }
+        if (!azureOpenAIApiDeploymentName) {
+            throw new Error("azureOpenAIApiDeploymentName is a required parameter when using azureOpenAIApiKey");
+        }
+        return `https://${azureOpenAIApiInstanceName}.openai.azure.com/openai/deployments/${azureOpenAIApiDeploymentName}`;
+    }
+    return baseURL;
+}
+exports.getEndpoint = getEndpoint;

package/dist/utils/azure.d.ts

@@ -0,0 +1,30 @@
+export interface OpenAIEndpointConfig {
+    azureOpenAIApiDeploymentName?: string;
+    azureOpenAIApiInstanceName?: string;
+    azureOpenAIApiKey?: string;
+    azureOpenAIBasePath?: string;
+    baseURL?: string;
+}
+/**
+ * This function generates an endpoint URL for (Azure) OpenAI
+ * based on the configuration parameters provided.
+ *
+ * @param {OpenAIEndpointConfig} config - The configuration object for the (Azure) endpoint.
+ *
+ * @property {string} config.azureOpenAIApiDeploymentName - The deployment name of Azure OpenAI.
+ * @property {string} config.azureOpenAIApiInstanceName - The instance name of Azure OpenAI.
+ * @property {string} config.azureOpenAIApiKey - The API Key for Azure OpenAI.
+ * @property {string} config.azureOpenAIBasePath - The base path for Azure OpenAI.
+ * @property {string} config.baseURL - Some other custom base path URL.
+ *
+ * The function operates as follows:
+ * - If both `azureOpenAIBasePath` and `azureOpenAIApiDeploymentName` (plus `azureOpenAIApiKey`) are provided, it returns an URL combining these two parameters (`${azureOpenAIBasePath}/${azureOpenAIApiDeploymentName}`).
+ * - If `azureOpenAIApiKey` is provided, it checks for `azureOpenAIApiInstanceName` and `azureOpenAIApiDeploymentName` and throws an error if any of these is missing. If both are provided, it generates an URL incorporating these parameters.
+ * - If none of the above conditions are met, return any custom `baseURL`.
+ * - The function returns the generated URL as a string, or undefined if no custom paths are specified.
+ *
+ * @throws Will throw an error if the necessary parameters for generating the URL are missing.
+ *
+ * @returns {string | undefined} The generated (Azure) OpenAI endpoint URL.
+ */
+export declare function getEndpoint(config: OpenAIEndpointConfig): string | undefined;

package/dist/utils/azure.js

@@ -0,0 +1,40 @@
+/**
+ * This function generates an endpoint URL for (Azure) OpenAI
+ * based on the configuration parameters provided.
+ *
+ * @param {OpenAIEndpointConfig} config - The configuration object for the (Azure) endpoint.
+ *
+ * @property {string} config.azureOpenAIApiDeploymentName - The deployment name of Azure OpenAI.
+ * @property {string} config.azureOpenAIApiInstanceName - The instance name of Azure OpenAI.
+ * @property {string} config.azureOpenAIApiKey - The API Key for Azure OpenAI.
+ * @property {string} config.azureOpenAIBasePath - The base path for Azure OpenAI.
+ * @property {string} config.baseURL - Some other custom base path URL.
+ *
+ * The function operates as follows:
+ * - If both `azureOpenAIBasePath` and `azureOpenAIApiDeploymentName` (plus `azureOpenAIApiKey`) are provided, it returns an URL combining these two parameters (`${azureOpenAIBasePath}/${azureOpenAIApiDeploymentName}`).
+ * - If `azureOpenAIApiKey` is provided, it checks for `azureOpenAIApiInstanceName` and `azureOpenAIApiDeploymentName` and throws an error if any of these is missing. If both are provided, it generates an URL incorporating these parameters.
+ * - If none of the above conditions are met, return any custom `baseURL`.
+ * - The function returns the generated URL as a string, or undefined if no custom paths are specified.
+ *
+ * @throws Will throw an error if the necessary parameters for generating the URL are missing.
+ *
+ * @returns {string | undefined} The generated (Azure) OpenAI endpoint URL.
+ */
+export function getEndpoint(config) {
+    const { azureOpenAIApiDeploymentName, azureOpenAIApiInstanceName, azureOpenAIApiKey, azureOpenAIBasePath, baseURL, } = config;
+    if (azureOpenAIApiKey &&
+        azureOpenAIBasePath &&
+        azureOpenAIApiDeploymentName) {
+        return `${azureOpenAIBasePath}/${azureOpenAIApiDeploymentName}`;
+    }
+    if (azureOpenAIApiKey) {
+        if (!azureOpenAIApiInstanceName) {
+            throw new Error("azureOpenAIApiInstanceName is required when using azureOpenAIApiKey");
+        }
+        if (!azureOpenAIApiDeploymentName) {
+            throw new Error("azureOpenAIApiDeploymentName is a required parameter when using azureOpenAIApiKey");
+        }
+        return `https://${azureOpenAIApiInstanceName}.openai.azure.com/openai/deployments/${azureOpenAIApiDeploymentName}`;
+    }
+    return baseURL;
+}

package/dist/utils/chunk.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkArray = void 0;
+const chunkArray = (arr, chunkSize) => arr.reduce((chunks, elem, index) => {
+    const chunkIndex = Math.floor(index / chunkSize);
+    const chunk = chunks[chunkIndex] || [];
+    // eslint-disable-next-line no-param-reassign
+    chunks[chunkIndex] = chunk.concat([elem]);
+    return chunks;
+}, []);
+exports.chunkArray = chunkArray;

package/dist/utils/chunk.d.ts

@@ -0,0 +1 @@
+export declare const chunkArray: <T>(arr: T[], chunkSize: number) => T[][];

package/dist/utils/chunk.js

@@ -0,0 +1,7 @@
+export const chunkArray = (arr, chunkSize) => arr.reduce((chunks, elem, index) => {
+    const chunkIndex = Math.floor(index / chunkSize);
+    const chunk = chunks[chunkIndex] || [];
+    // eslint-disable-next-line no-param-reassign
+    chunks[chunkIndex] = chunk.concat([elem]);
+    return chunks;
+}, []);

package/dist/utils/openai-format-fndef.cjs

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFunctionDefinitions = void 0;
+function isAnyOfProp(prop) {
+    return (prop.anyOf !== undefined &&
+        Array.isArray(prop.anyOf));
+}
+// When OpenAI use functions in the prompt, they format them as TypeScript definitions rather than OpenAPI JSON schemas.
+// This function converts the JSON schemas into TypeScript definitions.
+function formatFunctionDefinitions(functions) {
+    const lines = ["namespace functions {", ""];
+    for (const f of functions) {
+        if (f.description) {
+            lines.push(`// ${f.description}`);
+        }
+        if (Object.keys(f.parameters.properties ?? {}).length > 0) {
+            lines.push(`type ${f.name} = (_: {`);
+            lines.push(formatObjectProperties(f.parameters, 0));
+            lines.push("}) => any;");
+        }
+        else {
+            lines.push(`type ${f.name} = () => any;`);
+        }
+        lines.push("");
+    }
+    lines.push("} // namespace functions");
+    return lines.join("\n");
+}
+exports.formatFunctionDefinitions = formatFunctionDefinitions;
+// Format just the properties of an object (not including the surrounding braces)
+function formatObjectProperties(obj, indent) {
+    const lines = [];
+    for (const [name, param] of Object.entries(obj.properties ?? {})) {
+        if (param.description && indent < 2) {
+            lines.push(`// ${param.description}`);
+        }
+        if (obj.required?.includes(name)) {
+            lines.push(`${name}: ${formatType(param, indent)},`);
+        }
+        else {
+            lines.push(`${name}?: ${formatType(param, indent)},`);
+        }
+    }
+    return lines.map((line) => " ".repeat(indent) + line).join("\n");
+}
+// Format a single property type
+function formatType(param, indent) {
+    if (isAnyOfProp(param)) {
+        return param.anyOf.map((v) => formatType(v, indent)).join(" | ");
+    }
+    switch (param.type) {
+        case "string":
+            if (param.enum) {
+                return param.enum.map((v) => `"${v}"`).join(" | ");
+            }
+            return "string";
+        case "number":
+            if (param.enum) {
+                return param.enum.map((v) => `${v}`).join(" | ");
+            }
+            return "number";
+        case "integer":
+            if (param.enum) {
+                return param.enum.map((v) => `${v}`).join(" | ");
+            }
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "null":
+            return "null";
+        case "object":
+            return ["{", formatObjectProperties(param, indent + 2), "}"].join("\n");
+        case "array":
+            if (param.items) {
+                return `${formatType(param.items, indent)}[]`;
+            }
+            return "any[]";
+        default:
+            return "";
+    }
+}

package/dist/utils/openai-format-fndef.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Formatting function definitions for calculating openai function defination token usage.
+ *
+ * https://github.com/hmarr/openai-chat-tokens/blob/main/src/functions.ts
+ * (c) 2023 Harry Marr
+ * MIT license
+ */
+import OpenAI from "openai";
+type OpenAIFunction = OpenAI.Chat.ChatCompletionCreateParams.Function;
+export interface FunctionDef extends Omit<OpenAIFunction, "parameters"> {
+    name: string;
+    description?: string;
+    parameters: ObjectProp;
+}
+interface ObjectProp {
+    type: "object";
+    properties?: {
+        [key: string]: Prop;
+    };
+    required?: string[];
+}
+interface AnyOfProp {
+    anyOf: Prop[];
+}
+type Prop = {
+    description?: string;
+} & (AnyOfProp | ObjectProp | {
+    type: "string";
+    enum?: string[];
+} | {
+    type: "number" | "integer";
+    minimum?: number;
+    maximum?: number;
+    enum?: number[];
+} | {
+    type: "boolean";
+} | {
+    type: "null";
+} | {
+    type: "array";
+    items?: Prop;
+});
+export declare function formatFunctionDefinitions(functions: FunctionDef[]): string;
+export {};

package/dist/utils/openai-format-fndef.js

@@ -0,0 +1,77 @@
+function isAnyOfProp(prop) {
+    return (prop.anyOf !== undefined &&
+        Array.isArray(prop.anyOf));
+}
+// When OpenAI use functions in the prompt, they format them as TypeScript definitions rather than OpenAPI JSON schemas.
+// This function converts the JSON schemas into TypeScript definitions.
+export function formatFunctionDefinitions(functions) {
+    const lines = ["namespace functions {", ""];
+    for (const f of functions) {
+        if (f.description) {
+            lines.push(`// ${f.description}`);
+        }
+        if (Object.keys(f.parameters.properties ?? {}).length > 0) {
+            lines.push(`type ${f.name} = (_: {`);
+            lines.push(formatObjectProperties(f.parameters, 0));
+            lines.push("}) => any;");
+        }
+        else {
+            lines.push(`type ${f.name} = () => any;`);
+        }
+        lines.push("");
+    }
+    lines.push("} // namespace functions");
+    return lines.join("\n");
+}
+// Format just the properties of an object (not including the surrounding braces)
+function formatObjectProperties(obj, indent) {
+    const lines = [];
+    for (const [name, param] of Object.entries(obj.properties ?? {})) {
+        if (param.description && indent < 2) {
+            lines.push(`// ${param.description}`);
+        }
+        if (obj.required?.includes(name)) {
+            lines.push(`${name}: ${formatType(param, indent)},`);
+        }
+        else {
+            lines.push(`${name}?: ${formatType(param, indent)},`);
+        }
+    }
+    return lines.map((line) => " ".repeat(indent) + line).join("\n");
+}
+// Format a single property type
+function formatType(param, indent) {
+    if (isAnyOfProp(param)) {
+        return param.anyOf.map((v) => formatType(v, indent)).join(" | ");
+    }
+    switch (param.type) {
+        case "string":
+            if (param.enum) {
+                return param.enum.map((v) => `"${v}"`).join(" | ");
+            }
+            return "string";
+        case "number":
+            if (param.enum) {
+                return param.enum.map((v) => `${v}`).join(" | ");
+            }
+            return "number";
+        case "integer":
+            if (param.enum) {
+                return param.enum.map((v) => `${v}`).join(" | ");
+            }
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "null":
+            return "null";
+        case "object":
+            return ["{", formatObjectProperties(param, indent + 2), "}"].join("\n");
+        case "array":
+            if (param.items) {
+                return `${formatType(param.items, indent)}[]`;
+            }
+            return "any[]";
+        default:
+            return "";
+    }
+}

package/dist/utils/openai.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatToOpenAIAssistantTool = exports.formatToOpenAITool = exports.formatToOpenAIFunction = exports.wrapOpenAIClientError = void 0;
+const openai_1 = require("openai");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function wrapOpenAIClientError(e) {
+    let error;
+    if (e.constructor.name === openai_1.APIConnectionTimeoutError.name) {
+        error = new Error(e.message);
+        error.name = "TimeoutError";
+    }
+    else if (e.constructor.name === openai_1.APIUserAbortError.name) {
+        error = new Error(e.message);
+        error.name = "AbortError";
+    }
+    else {
+        error = e;
+    }
+    return error;
+}
+exports.wrapOpenAIClientError = wrapOpenAIClientError;
+/**
+ * Formats a `StructuredTool` instance into a format that is compatible
+ * with OpenAI's ChatCompletionFunctions. It uses the `zodToJsonSchema`
+ * function to convert the schema of the `StructuredTool` into a JSON
+ * schema, which is then used as the parameters for the OpenAI function.
+ */
+function formatToOpenAIFunction(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema),
+    };
+}
+exports.formatToOpenAIFunction = formatToOpenAIFunction;
+function formatToOpenAITool(tool) {
+    const schema = (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema);
+    return {
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: schema,
+        },
+    };
+}
+exports.formatToOpenAITool = formatToOpenAITool;
+function formatToOpenAIAssistantTool(tool) {
+    return {
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema),
+        },
+    };
+}
+exports.formatToOpenAIAssistantTool = formatToOpenAIAssistantTool;

package/dist/utils/openai.d.ts

@@ -0,0 +1,12 @@
+import { type OpenAI as OpenAIClient } from "openai";
+import { StructuredTool } from "@langchain/core/tools";
+export declare function wrapOpenAIClientError(e: any): any;
+/**
+ * Formats a `StructuredTool` instance into a format that is compatible
+ * with OpenAI's ChatCompletionFunctions. It uses the `zodToJsonSchema`
+ * function to convert the schema of the `StructuredTool` into a JSON
+ * schema, which is then used as the parameters for the OpenAI function.
+ */
+export declare function formatToOpenAIFunction(tool: StructuredTool): OpenAIClient.Chat.ChatCompletionCreateParams.Function;
+export declare function formatToOpenAITool(tool: StructuredTool): OpenAIClient.Chat.ChatCompletionTool;
+export declare function formatToOpenAIAssistantTool(tool: StructuredTool): OpenAIClient.Beta.AssistantCreateParams.AssistantToolsFunction;

package/dist/utils/openai.js

@@ -0,0 +1,52 @@
+import { APIConnectionTimeoutError, APIUserAbortError, } from "openai";
+import { zodToJsonSchema } from "zod-to-json-schema";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function wrapOpenAIClientError(e) {
+    let error;
+    if (e.constructor.name === APIConnectionTimeoutError.name) {
+        error = new Error(e.message);
+        error.name = "TimeoutError";
+    }
+    else if (e.constructor.name === APIUserAbortError.name) {
+        error = new Error(e.message);
+        error.name = "AbortError";
+    }
+    else {
+        error = e;
+    }
+    return error;
+}
+/**
+ * Formats a `StructuredTool` instance into a format that is compatible
+ * with OpenAI's ChatCompletionFunctions. It uses the `zodToJsonSchema`
+ * function to convert the schema of the `StructuredTool` into a JSON
+ * schema, which is then used as the parameters for the OpenAI function.
+ */
+export function formatToOpenAIFunction(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        parameters: zodToJsonSchema(tool.schema),
+    };
+}
+export function formatToOpenAITool(tool) {
+    const schema = zodToJsonSchema(tool.schema);
+    return {
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: schema,
+        },
+    };
+}
+export function formatToOpenAIAssistantTool(tool) {
+    return {
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: zodToJsonSchema(tool.schema),
+        },
+    };
+}

package/index.cjs

@@ -0,0 +1 @@
+module.exports = require('./dist/index.cjs');

package/index.d.ts

@@ -0,0 +1 @@
+export * from './dist/index.js'

package/index.js

@@ -0,0 +1 @@
+export * from './dist/index.js'

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@langchain/openai",
+  "version": "0.0.0",
+  "description": "OpenAI integrations for LangChain.js",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:langchain-ai/langchainjs.git"
+  },
+  "scripts": {
+    "build": "yarn clean && yarn build:esm && yarn build:cjs && yarn build:scripts",
+    "build:esm": "NODE_OPTIONS=--max-old-space-size=4096 tsc --outDir dist/",
+    "build:cjs": "NODE_OPTIONS=--max-old-space-size=4096 tsc --outDir dist-cjs/ -p tsconfig.cjs.json && node scripts/move-cjs-to-dist.js && rimraf dist-cjs",
+    "build:watch": "node scripts/create-entrypoints.js && tsc --outDir dist/ --watch",
+    "build:scripts": "node scripts/create-entrypoints.js && node scripts/check-tree-shaking.js",
+    "lint": "NODE_OPTIONS=--max-old-space-size=4096 eslint src && dpdm --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
+    "lint:fix": "yarn lint --fix",
+    "clean": "rimraf dist/ && NODE_OPTIONS=--max-old-space-size=4096 node scripts/create-entrypoints.js pre",
+    "prepack": "yarn build",
+    "release": "release-it --only-version --config .release-it.json",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --testPathIgnorePatterns=\\.int\\.test.ts --testTimeout 30000 --maxWorkers=50%",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --testPathIgnorePatterns=\\.int\\.test.ts",
+    "test:single": "NODE_OPTIONS=--experimental-vm-modules yarn run jest --config jest.config.cjs --testTimeout 100000",
+    "format": "prettier --write \"src\"",
+    "format:check": "prettier --check \"src\""
+  },
+  "author": "LangChain",
+  "license": "MIT",
+  "dependencies": {
+    "@langchain/core": "^0.0.0",
+    "js-tiktoken": "^1.0.7",
+    "openai": "^4.19.0",
+    "zod-to-json-schema": "3.20.3"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@langchain/core": "workspace:*",
+    "@swc/core": "^1.3.90",
+    "@swc/jest": "^0.2.29",
+    "dpdm": "^3.12.0",
+    "eslint": "^8.33.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-no-instanceof": "^1.0.1",
+    "eslint-plugin-prettier": "^4.2.1",
+    "jest": "^29.5.0",
+    "jest-environment-node": "^29.6.4",
+    "prettier": "^2.8.3",
+    "release-it": "^15.10.1",
+    "rimraf": "^5.0.1",
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "llm",
+    "ai",
+    "gpt3",
+    "chain",
+    "prompt",
+    "prompt engineering",
+    "chatgpt",
+    "machine learning",
+    "ml",
+    "openai",
+    "embeddings",
+    "vectorstores"
+  ],
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/",
+    "index.cjs",
+    "index.js",
+    "index.d.ts"
+  ]
+}