@langchain/openai 0.6.16 → 1.0.0-alpha.2

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

@@ -1,44 +0,0 @@
-/**
- * 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

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

@@ -1,127 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatToOpenAITool = exports.formatToOpenAIFunction = void 0;
-exports.wrapOpenAIClientError = wrapOpenAIClientError;
-exports.formatToOpenAIAssistantTool = formatToOpenAIAssistantTool;
-exports.formatToOpenAIToolChoice = formatToOpenAIToolChoice;
-exports.interopZodResponseFormat = interopZodResponseFormat;
-const openai_1 = require("openai");
-const function_calling_1 = require("@langchain/core/utils/function_calling");
-Object.defineProperty(exports, "formatToOpenAIFunction", { enumerable: true, get: function () { return function_calling_1.convertToOpenAIFunction; } });
-Object.defineProperty(exports, "formatToOpenAITool", { enumerable: true, get: function () { return function_calling_1.convertToOpenAITool; } });
-const types_1 = require("@langchain/core/utils/types");
-const json_schema_1 = require("@langchain/core/utils/json_schema");
-const core_1 = require("zod/v4/core");
-const zod_1 = require("openai/helpers/zod");
-const errors_js_1 = require("./errors.cjs");
-// 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 if (e.status === 400 && e.message.includes("tool_calls")) {
-        error = (0, errors_js_1.addLangChainErrorFields)(e, "INVALID_TOOL_RESULTS");
-    }
-    else if (e.status === 401) {
-        error = (0, errors_js_1.addLangChainErrorFields)(e, "MODEL_AUTHENTICATION");
-    }
-    else if (e.status === 429) {
-        error = (0, errors_js_1.addLangChainErrorFields)(e, "MODEL_RATE_LIMIT");
-    }
-    else if (e.status === 404) {
-        error = (0, errors_js_1.addLangChainErrorFields)(e, "MODEL_NOT_FOUND");
-    }
-    else {
-        error = e;
-    }
-    return error;
-}
-function formatToOpenAIAssistantTool(tool) {
-    return {
-        type: "function",
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: (0, types_1.isInteropZodSchema)(tool.schema)
-                ? (0, json_schema_1.toJsonSchema)(tool.schema)
-                : tool.schema,
-        },
-    };
-}
-function formatToOpenAIToolChoice(toolChoice) {
-    if (!toolChoice) {
-        return undefined;
-    }
-    else if (toolChoice === "any" || toolChoice === "required") {
-        return "required";
-    }
-    else if (toolChoice === "auto") {
-        return "auto";
-    }
-    else if (toolChoice === "none") {
-        return "none";
-    }
-    else if (typeof toolChoice === "string") {
-        return {
-            type: "function",
-            function: {
-                name: toolChoice,
-            },
-        };
-    }
-    else {
-        return toolChoice;
-    }
-}
-// inlined from openai/lib/parser.ts
-function makeParseableResponseFormat(response_format, parser) {
-    const obj = { ...response_format };
-    Object.defineProperties(obj, {
-        $brand: {
-            value: "auto-parseable-response-format",
-            enumerable: false,
-        },
-        $parseRaw: {
-            value: parser,
-            enumerable: false,
-        },
-    });
-    return obj;
-}
-function interopZodResponseFormat(zodSchema, name, props) {
-    if ((0, types_1.isZodSchemaV3)(zodSchema)) {
-        return (0, zod_1.zodResponseFormat)(zodSchema, name, props);
-    }
-    if ((0, types_1.isZodSchemaV4)(zodSchema)) {
-        return makeParseableResponseFormat({
-            type: "json_schema",
-            json_schema: {
-                ...props,
-                name,
-                strict: true,
-                schema: (0, core_1.toJSONSchema)(zodSchema, {
-                    cycles: "ref", // equivalent to nameStrategy: 'duplicate-ref'
-                    reused: "ref", // equivalent to $refStrategy: 'extract-to-root'
-                    override(ctx) {
-                        ctx.jsonSchema.title = name; // equivalent to `name` property
-                        // TODO: implement `nullableStrategy` patch-fix (zod doesn't support openApi3 json schema target)
-                        // TODO: implement `openaiStrictMode` patch-fix (where optional properties without `nullable` are not supported)
-                    },
-                    /// property equivalents from native `zodResponseFormat` fn
-                    // openaiStrictMode: true,
-                    // name,
-                    // nameStrategy: 'duplicate-ref',
-                    // $refStrategy: 'extract-to-root',
-                    // nullableStrategy: 'property',
-                }),
-            },
-        }, (content) => (0, core_1.parse)(zodSchema, JSON.parse(content)));
-    }
-    throw new Error("Unsupported schema response format");
-}

package/dist/utils/openai.d.ts

@@ -1,15 +0,0 @@
-import { OpenAI as OpenAIClient } from "openai";
-import type { StructuredToolInterface } from "@langchain/core/tools";
-import { convertToOpenAIFunction, convertToOpenAITool } from "@langchain/core/utils/function_calling";
-import { ToolDefinition } from "@langchain/core/language_models/base";
-import { InteropZodType } from "@langchain/core/utils/types";
-import { ResponseFormatJSONSchema } from "openai/resources";
-export declare function wrapOpenAIClientError(e: any): any;
-export { convertToOpenAIFunction as formatToOpenAIFunction, convertToOpenAITool as formatToOpenAITool, };
-export declare function formatToOpenAIAssistantTool(tool: StructuredToolInterface): ToolDefinition;
-export type OpenAIToolChoice = OpenAIClient.ChatCompletionToolChoiceOption | "any" | string;
-export declare function formatToOpenAIToolChoice(toolChoice?: OpenAIToolChoice): OpenAIClient.ChatCompletionToolChoiceOption | undefined;
-export declare function interopZodResponseFormat(zodSchema: InteropZodType, name: string, props: Omit<ResponseFormatJSONSchema.JSONSchema, "schema" | "strict" | "name">): {
-    json_schema: ResponseFormatJSONSchema.JSONSchema;
-    type: "json_schema";
-};

package/dist/utils/openai.js

@@ -1,119 +0,0 @@
-import { APIConnectionTimeoutError, APIUserAbortError, } from "openai";
-import { convertToOpenAIFunction, convertToOpenAITool, } from "@langchain/core/utils/function_calling";
-import { isInteropZodSchema, isZodSchemaV3, isZodSchemaV4, } from "@langchain/core/utils/types";
-import { toJsonSchema } from "@langchain/core/utils/json_schema";
-import { toJSONSchema as toJSONSchemaV4, parse as parseV4 } from "zod/v4/core";
-import { zodResponseFormat } from "openai/helpers/zod";
-import { addLangChainErrorFields } from "./errors.js";
-// 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 if (e.status === 400 && e.message.includes("tool_calls")) {
-        error = addLangChainErrorFields(e, "INVALID_TOOL_RESULTS");
-    }
-    else if (e.status === 401) {
-        error = addLangChainErrorFields(e, "MODEL_AUTHENTICATION");
-    }
-    else if (e.status === 429) {
-        error = addLangChainErrorFields(e, "MODEL_RATE_LIMIT");
-    }
-    else if (e.status === 404) {
-        error = addLangChainErrorFields(e, "MODEL_NOT_FOUND");
-    }
-    else {
-        error = e;
-    }
-    return error;
-}
-export { convertToOpenAIFunction as formatToOpenAIFunction, convertToOpenAITool as formatToOpenAITool, };
-export function formatToOpenAIAssistantTool(tool) {
-    return {
-        type: "function",
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: isInteropZodSchema(tool.schema)
-                ? toJsonSchema(tool.schema)
-                : tool.schema,
-        },
-    };
-}
-export function formatToOpenAIToolChoice(toolChoice) {
-    if (!toolChoice) {
-        return undefined;
-    }
-    else if (toolChoice === "any" || toolChoice === "required") {
-        return "required";
-    }
-    else if (toolChoice === "auto") {
-        return "auto";
-    }
-    else if (toolChoice === "none") {
-        return "none";
-    }
-    else if (typeof toolChoice === "string") {
-        return {
-            type: "function",
-            function: {
-                name: toolChoice,
-            },
-        };
-    }
-    else {
-        return toolChoice;
-    }
-}
-// inlined from openai/lib/parser.ts
-function makeParseableResponseFormat(response_format, parser) {
-    const obj = { ...response_format };
-    Object.defineProperties(obj, {
-        $brand: {
-            value: "auto-parseable-response-format",
-            enumerable: false,
-        },
-        $parseRaw: {
-            value: parser,
-            enumerable: false,
-        },
-    });
-    return obj;
-}
-export function interopZodResponseFormat(zodSchema, name, props) {
-    if (isZodSchemaV3(zodSchema)) {
-        return zodResponseFormat(zodSchema, name, props);
-    }
-    if (isZodSchemaV4(zodSchema)) {
-        return makeParseableResponseFormat({
-            type: "json_schema",
-            json_schema: {
-                ...props,
-                name,
-                strict: true,
-                schema: toJSONSchemaV4(zodSchema, {
-                    cycles: "ref", // equivalent to nameStrategy: 'duplicate-ref'
-                    reused: "ref", // equivalent to $refStrategy: 'extract-to-root'
-                    override(ctx) {
-                        ctx.jsonSchema.title = name; // equivalent to `name` property
-                        // TODO: implement `nullableStrategy` patch-fix (zod doesn't support openApi3 json schema target)
-                        // TODO: implement `openaiStrictMode` patch-fix (where optional properties without `nullable` are not supported)
-                    },
-                    /// property equivalents from native `zodResponseFormat` fn
-                    // openaiStrictMode: true,
-                    // name,
-                    // nameStrategy: 'duplicate-ref',
-                    // $refStrategy: 'extract-to-root',
-                    // nullableStrategy: 'property',
-                }),
-            },
-        }, (content) => parseV4(zodSchema, JSON.parse(content)));
-    }
-    throw new Error("Unsupported schema response format");
-}

package/dist/utils/output.d.ts

@@ -1,11 +0,0 @@
-import { OpenAI as OpenAIClient } from "openai";
-import { StandardImageBlock, StandardTextBlock, UsageMetadata } from "@langchain/core/messages";
-/**
- * Handle multi modal response content.
- *
- * @param content The content of the message.
- * @param messages The messages of the response.
- * @returns The new content of the message.
- */
-export declare function handleMultiModalOutput(content: string, messages: unknown): (StandardImageBlock | StandardTextBlock)[] | string;
-export declare function _convertOpenAIResponsesUsageToLangChainUsage(usage?: OpenAIClient.Responses.ResponseUsage): UsageMetadata;

package/index.cjs

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

package/index.d.cts

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

package/index.d.ts

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

package/index.js

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