@aigne/openai 0.16.16 → 1.74.0-beta

package/lib/cjs/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./openai-chat-model.js";
-export * from "./openai-image-model.js";
-export * from "./openai-video-model.js";

package/lib/cjs/index.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./openai-chat-model.js"), exports);
-__exportStar(require("./openai-image-model.js"), exports);
-__exportStar(require("./openai-video-model.js"), exports);

package/lib/cjs/openai-chat-model.d.ts

@@ -1,160 +0,0 @@
-import { type AgentInvokeOptions, type AgentProcessResult, ChatModel, type ChatModelInput, type ChatModelInputMessage, type ChatModelInputTool, type ChatModelOptions, type ChatModelOutput } from "@aigne/core";
-import { type PromiseOrValue } from "@aigne/core/utils/type-utils.js";
-import type { ClientOptions, OpenAI } from "openai";
-import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
-import { z } from "zod";
-export interface OpenAIChatModelCapabilities {
-    supportsNativeStructuredOutputs: boolean;
-    supportsEndWithSystemMessage: boolean;
-    supportsToolsUseWithJsonSchema: boolean;
-    supportsParallelToolCalls: boolean;
-    supportsToolsEmptyParameters: boolean;
-    supportsToolStreaming: boolean;
-    supportsTemperature: boolean;
-}
-/**
- * Configuration options for OpenAI Chat Model
- */
-export interface OpenAIChatModelOptions extends ChatModelOptions {
-    /**
-     * API key for OpenAI API
-     *
-     * If not provided, will look for OPENAI_API_KEY in environment variables
-     */
-    apiKey?: string;
-    /**
-     * Base URL for OpenAI API
-     *
-     * Useful for proxies or alternate endpoints
-     */
-    baseURL?: string;
-    /**
-     * Client options for OpenAI API
-     */
-    clientOptions?: Partial<ClientOptions>;
-}
-/**
- * @hidden
- */
-export declare const openAIChatModelOptionsSchema: z.ZodObject<{
-    apiKey: z.ZodOptional<z.ZodString>;
-    baseURL: z.ZodOptional<z.ZodString>;
-    model: z.ZodOptional<z.ZodString>;
-    modelOptions: z.ZodOptional<z.ZodObject<{
-        model: z.ZodOptional<z.ZodString>;
-        temperature: z.ZodOptional<z.ZodNumber>;
-        topP: z.ZodOptional<z.ZodNumber>;
-        frequencyPenalty: z.ZodOptional<z.ZodNumber>;
-        presencePenalty: z.ZodOptional<z.ZodNumber>;
-        parallelToolCalls: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        parallelToolCalls: boolean;
-        model?: string | undefined;
-        temperature?: number | undefined;
-        topP?: number | undefined;
-        frequencyPenalty?: number | undefined;
-        presencePenalty?: number | undefined;
-    }, {
-        model?: string | undefined;
-        temperature?: number | undefined;
-        topP?: number | undefined;
-        frequencyPenalty?: number | undefined;
-        presencePenalty?: number | undefined;
-        parallelToolCalls?: boolean | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    model?: string | undefined;
-    apiKey?: string | undefined;
-    baseURL?: string | undefined;
-    modelOptions?: {
-        parallelToolCalls: boolean;
-        model?: string | undefined;
-        temperature?: number | undefined;
-        topP?: number | undefined;
-        frequencyPenalty?: number | undefined;
-        presencePenalty?: number | undefined;
-    } | undefined;
-}, {
-    model?: string | undefined;
-    apiKey?: string | undefined;
-    baseURL?: string | undefined;
-    modelOptions?: {
-        model?: string | undefined;
-        temperature?: number | undefined;
-        topP?: number | undefined;
-        frequencyPenalty?: number | undefined;
-        presencePenalty?: number | undefined;
-        parallelToolCalls?: boolean | undefined;
-    } | undefined;
-}>;
-/**
- * Implementation of the ChatModel interface for OpenAI's API
- *
- * This model provides access to OpenAI's capabilities including:
- * - Text generation
- * - Tool use with parallel tool calls
- * - JSON structured output
- * - Image understanding
- *
- * Default model: 'gpt-4o-mini'
- *
- * @example
- * Here's how to create and use an OpenAI chat model:
- * {@includeCode ../test/openai-chat-model.test.ts#example-openai-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../test/openai-chat-model.test.ts#example-openai-chat-model-stream}
- */
-export declare class OpenAIChatModel extends ChatModel {
-    options?: OpenAIChatModelOptions | undefined;
-    constructor(options?: OpenAIChatModelOptions | undefined);
-    /**
-     * @hidden
-     */
-    protected _client?: OpenAI;
-    protected apiKeyEnvName: string;
-    protected apiKeyDefault: string | undefined;
-    protected supportsNativeStructuredOutputs: boolean;
-    protected supportsToolsUseWithJsonSchema: boolean;
-    protected supportsParallelToolCalls: boolean;
-    protected supportsToolsEmptyParameters: boolean;
-    protected supportsToolStreaming: boolean;
-    protected supportsTemperature: boolean;
-    get client(): OpenAI;
-    get credential(): {
-        url: string | undefined;
-        apiKey: string | undefined;
-        model: string;
-    };
-    /**
-     * Process the input and generate a response
-     * @param input The input to process
-     * @returns The generated response
-     */
-    process(input: ChatModelInput, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
-    private getReasoningEffort;
-    private _process;
-    private getParallelToolCalls;
-    protected getRunMessages(input: ChatModelInput): Promise<ChatCompletionMessageParam[]>;
-    private getRunResponseFormat;
-    private requestStructuredOutput;
-    private extractResultFromStream;
-    /**
-     * Controls how optional fields are handled in JSON schema conversion
-     * - "anyOf": All fields are required but can be null (default)
-     * - "optional": Fields marked as optional in schema remain optional
-     */
-    protected optionalFieldMode?: "anyOf" | "optional";
-    protected jsonSchemaToOpenAIJsonSchema(schema: Record<string, unknown>): Record<string, unknown>;
-}
-/**
- * @hidden
- */
-export declare function contentsFromInputMessages(messages: ChatModelInputMessage[]): Promise<ChatCompletionMessageParam[]>;
-/**
- * @hidden
- */
-export declare function toolsFromInputTools(tools?: ChatModelInputTool[], options?: {
-    addTypeToEmptyParameters?: boolean;
-}): ChatCompletionTool[] | undefined;

package/lib/cjs/openai-chat-model.js

@@ -1,465 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAIChatModel = exports.openAIChatModelOptionsSchema = void 0;
-exports.contentsFromInputMessages = contentsFromInputMessages;
-exports.toolsFromInputTools = toolsFromInputTools;
-const core_1 = require("@aigne/core");
-const logger_js_1 = require("@aigne/core/utils/logger.js");
-const model_utils_js_1 = require("@aigne/core/utils/model-utils.js");
-const prompts_js_1 = require("@aigne/core/utils/prompts.js");
-const stream_utils_js_1 = require("@aigne/core/utils/stream-utils.js");
-const type_utils_js_1 = require("@aigne/core/utils/type-utils.js");
-const uuid_1 = require("@aigne/uuid");
-const zod_1 = require("zod");
-const openai_js_1 = require("./openai.js");
-const CHAT_MODEL_OPENAI_DEFAULT_MODEL = "gpt-4o-mini";
-const OPENAI_CHAT_MODEL_CAPABILITIES = {
-    "o4-mini": { supportsParallelToolCalls: false, supportsTemperature: false },
-    "o3-mini": { supportsParallelToolCalls: false, supportsTemperature: false },
-};
-/**
- * @hidden
- */
-exports.openAIChatModelOptionsSchema = zod_1.z.object({
-    apiKey: zod_1.z.string().optional(),
-    baseURL: zod_1.z.string().optional(),
-    model: zod_1.z.string().optional(),
-    modelOptions: zod_1.z
-        .object({
-        model: zod_1.z.string().optional(),
-        temperature: zod_1.z.number().optional(),
-        topP: zod_1.z.number().optional(),
-        frequencyPenalty: zod_1.z.number().optional(),
-        presencePenalty: zod_1.z.number().optional(),
-        parallelToolCalls: zod_1.z.boolean().optional().default(true),
-    })
-        .optional(),
-});
-/**
- * Implementation of the ChatModel interface for OpenAI's API
- *
- * This model provides access to OpenAI's capabilities including:
- * - Text generation
- * - Tool use with parallel tool calls
- * - JSON structured output
- * - Image understanding
- *
- * Default model: 'gpt-4o-mini'
- *
- * @example
- * Here's how to create and use an OpenAI chat model:
- * {@includeCode ../test/openai-chat-model.test.ts#example-openai-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../test/openai-chat-model.test.ts#example-openai-chat-model-stream}
- */
-class OpenAIChatModel extends core_1.ChatModel {
-    options;
-    constructor(options) {
-        super();
-        this.options = options;
-        if (options)
-            (0, type_utils_js_1.checkArguments)(this.name, exports.openAIChatModelOptionsSchema, options);
-        const preset = options?.model ? OPENAI_CHAT_MODEL_CAPABILITIES[options.model] : undefined;
-        Object.assign(this, preset);
-    }
-    /**
-     * @hidden
-     */
-    _client;
-    apiKeyEnvName = "OPENAI_API_KEY";
-    apiKeyDefault;
-    supportsNativeStructuredOutputs = true;
-    supportsToolsUseWithJsonSchema = true;
-    supportsParallelToolCalls = true;
-    supportsToolsEmptyParameters = true;
-    supportsToolStreaming = true;
-    supportsTemperature = true;
-    get client() {
-        const { apiKey, url } = this.credential;
-        if (!apiKey)
-            throw new Error(`${this.name} requires an API key. Please provide it via \`options.apiKey\`, or set the \`${this.apiKeyEnvName}\` environment variable`);
-        this._client ??= new openai_js_1.CustomOpenAI({
-            baseURL: url,
-            apiKey,
-            ...this.options?.clientOptions,
-        });
-        return this._client;
-    }
-    get credential() {
-        return {
-            url: this.options?.baseURL || process.env.OPENAI_BASE_URL,
-            apiKey: this.options?.apiKey || process.env[this.apiKeyEnvName] || this.apiKeyDefault,
-            model: this.options?.model || CHAT_MODEL_OPENAI_DEFAULT_MODEL,
-        };
-    }
-    /**
-     * Process the input and generate a response
-     * @param input The input to process
-     * @returns The generated response
-     */
-    process(input, options) {
-        return this._process(input, options);
-    }
-    getReasoningEffort(effort) {
-        if (typeof effort === "number") {
-            if (effort > 5000)
-                return "high";
-            if (effort > 1000)
-                return "medium";
-            if (effort > 500)
-                return "low";
-            if (effort > 0)
-                return "minimal";
-            return undefined;
-        }
-        return effort;
-    }
-    async _process(input, _options) {
-        const { modelOptions = {} } = input;
-        const messages = await this.getRunMessages(input);
-        const model = modelOptions?.model || this.credential.model;
-        const body = {
-            model,
-            temperature: this.supportsTemperature ? modelOptions.temperature : undefined,
-            top_p: modelOptions.topP,
-            frequency_penalty: modelOptions.frequencyPenalty,
-            presence_penalty: modelOptions.presencePenalty,
-            messages,
-            stream_options: { include_usage: true },
-            stream: true,
-            reasoning_effort: this.getReasoningEffort(modelOptions.reasoningEffort),
-        };
-        if (model.includes("gpt-5") || model.includes("o1-")) {
-            delete body.temperature;
-            delete body.top_p;
-        }
-        // For models that do not support tools use with JSON schema in same request,
-        // so we need to handle the case where tools are not used and responseFormat is json
-        if (!input.tools?.length && input.responseFormat?.type === "json_schema") {
-            return await this.requestStructuredOutput(body, input.responseFormat);
-        }
-        const { jsonMode, responseFormat } = await this.getRunResponseFormat(input);
-        const stream = (await this.client.chat.completions.create({
-            ...body,
-            tools: toolsFromInputTools(input.tools, {
-                addTypeToEmptyParameters: !this.supportsToolsEmptyParameters,
-            }),
-            tool_choice: input.toolChoice,
-            parallel_tool_calls: this.getParallelToolCalls(input, modelOptions),
-            response_format: responseFormat,
-        }));
-        if (input.responseFormat?.type !== "json_schema") {
-            return await this.extractResultFromStream(body, stream, false, true);
-        }
-        const result = await this.extractResultFromStream(body, stream, jsonMode);
-        // Just return the result if it has tool calls
-        if (result.toolCalls?.length || result.json)
-            return result;
-        // Try to parse the text response as JSON
-        // If it matches the json_schema, return it as json
-        const json = (0, core_1.safeParseJSON)(result.text || "");
-        const validated = this.validateJsonSchema(input.responseFormat.jsonSchema.schema, json, {
-            safe: true,
-        });
-        if (validated.success) {
-            return { ...result, json: validated.data, text: undefined };
-        }
-        logger_js_1.logger.warn(`${this.name}: Text response does not match JSON schema, trying to use tool to extract json `, {
-            text: result.text,
-        });
-        const output = await this.requestStructuredOutput(body, input.responseFormat);
-        return { ...output, usage: (0, model_utils_js_1.mergeUsage)(result.usage, output.usage) };
-    }
-    getParallelToolCalls(input, modelOptions) {
-        if (!this.supportsParallelToolCalls)
-            return undefined;
-        if (!input.tools?.length)
-            return undefined;
-        return modelOptions.parallelToolCalls;
-    }
-    async getRunMessages(input) {
-        const messages = await contentsFromInputMessages(input.messages);
-        if (input.responseFormat?.type === "json_schema") {
-            if (!this.supportsNativeStructuredOutputs ||
-                (!this.supportsToolsUseWithJsonSchema && input.tools?.length)) {
-                messages.unshift({
-                    role: "system",
-                    content: (0, prompts_js_1.getJsonOutputPrompt)(input.responseFormat.jsonSchema.schema),
-                });
-            }
-        }
-        return messages;
-    }
-    async getRunResponseFormat(input) {
-        if (!this.supportsToolsUseWithJsonSchema && input.tools?.length)
-            return { jsonMode: false, responseFormat: undefined };
-        if (!this.supportsNativeStructuredOutputs) {
-            const jsonMode = input.responseFormat?.type === "json_schema";
-            return {
-                jsonMode,
-                responseFormat: jsonMode ? { type: "json_object" } : undefined,
-            };
-        }
-        if (input.responseFormat?.type === "json_schema") {
-            return {
-                jsonMode: true,
-                responseFormat: {
-                    type: "json_schema",
-                    json_schema: {
-                        ...input.responseFormat.jsonSchema,
-                        schema: this.jsonSchemaToOpenAIJsonSchema(input.responseFormat.jsonSchema.schema),
-                    },
-                },
-            };
-        }
-        return { jsonMode: false, responseFormat: undefined };
-    }
-    async requestStructuredOutput(body, responseFormat) {
-        if (responseFormat?.type !== "json_schema") {
-            throw new Error("Expected json_schema response format");
-        }
-        const { jsonMode, responseFormat: resolvedResponseFormat } = await this.getRunResponseFormat({
-            responseFormat,
-        });
-        const res = (await this.client.chat.completions.create({
-            ...body,
-            response_format: resolvedResponseFormat,
-        }));
-        return this.extractResultFromStream(body, res, jsonMode);
-    }
-    async extractResultFromStream(body, stream, jsonMode, streaming) {
-        const result = new ReadableStream({
-            start: async (controller) => {
-                try {
-                    controller.enqueue({
-                        delta: {
-                            json: {
-                                modelOptions: {
-                                    reasoningEffort: body.reasoning_effort,
-                                },
-                            },
-                        },
-                    });
-                    let text = "";
-                    let refusal = "";
-                    const toolCalls = [];
-                    let model;
-                    for await (const chunk of stream) {
-                        const choice = chunk.choices?.[0];
-                        const delta = choice?.delta;
-                        if (!model) {
-                            model = chunk.model;
-                            controller.enqueue({
-                                delta: {
-                                    json: {
-                                        model,
-                                    },
-                                },
-                            });
-                        }
-                        if (delta?.tool_calls?.length) {
-                            for (const call of delta.tool_calls) {
-                                if (this.supportsToolStreaming && call.index !== undefined) {
-                                    handleToolCallDelta(toolCalls, call);
-                                }
-                                else {
-                                    handleCompleteToolCall(toolCalls, call);
-                                }
-                            }
-                        }
-                        if (delta && "reasoning" in delta && typeof delta.reasoning === "string") {
-                            controller.enqueue({ delta: { text: { thoughts: delta.reasoning } } });
-                        }
-                        if (delta?.content) {
-                            text += delta.content;
-                            if (!jsonMode) {
-                                controller.enqueue({
-                                    delta: {
-                                        text: {
-                                            text: delta.content,
-                                        },
-                                    },
-                                });
-                            }
-                        }
-                        if (delta?.refusal) {
-                            refusal += delta.refusal;
-                        }
-                        if (chunk.usage) {
-                            const usage = {
-                                inputTokens: chunk.usage.prompt_tokens,
-                                outputTokens: chunk.usage.completion_tokens,
-                            };
-                            // Parse cache statistics if available
-                            const inputDetails = chunk.usage.prompt_tokens_details;
-                            if (inputDetails?.cached_tokens) {
-                                usage.cacheReadInputTokens = inputDetails.cached_tokens;
-                            }
-                            controller.enqueue({
-                                delta: {
-                                    json: {
-                                        usage,
-                                    },
-                                },
-                            });
-                        }
-                    }
-                    if (jsonMode && text) {
-                        controller.enqueue({
-                            delta: {
-                                json: {
-                                    json: (0, core_1.safeParseJSON)(text),
-                                },
-                            },
-                        });
-                    }
-                    if (toolCalls.length) {
-                        controller.enqueue({
-                            delta: {
-                                json: {
-                                    toolCalls: toolCalls.map(({ args, ...c }) => ({
-                                        ...c,
-                                        function: { ...c.function, arguments: args ? (0, core_1.safeParseJSON)(args) : {} },
-                                    })),
-                                },
-                            },
-                        });
-                    }
-                    if (refusal) {
-                        controller.error(new Error(`Got refusal from LLM: ${refusal}`));
-                    }
-                    controller.close();
-                }
-                catch (error) {
-                    controller.error(error);
-                }
-            },
-        });
-        return streaming ? result : await (0, stream_utils_js_1.agentResponseStreamToObject)(result);
-    }
-    /**
-     * Controls how optional fields are handled in JSON schema conversion
-     * - "anyOf": All fields are required but can be null (default)
-     * - "optional": Fields marked as optional in schema remain optional
-     */
-    optionalFieldMode = "anyOf";
-    jsonSchemaToOpenAIJsonSchema(schema) {
-        if (schema?.type === "object") {
-            const s = schema;
-            const required = this.optionalFieldMode === "anyOf" ? Object.keys(s.properties) : s.required;
-            return {
-                ...schema,
-                properties: Object.fromEntries(Object.entries(s.properties).map(([key, value]) => {
-                    const valueSchema = this.jsonSchemaToOpenAIJsonSchema(value);
-                    // NOTE: All fields must be required https://platform.openai.com/docs/guides/structured-outputs/all-fields-must-be-required
-                    return [
-                        key,
-                        this.optionalFieldMode === "optional" || s.required?.includes(key)
-                            ? valueSchema
-                            : { anyOf: [valueSchema, { type: ["null"] }] },
-                    ];
-                })),
-                required,
-            };
-        }
-        if (schema?.type === "array") {
-            const { items } = schema;
-            return {
-                ...schema,
-                items: this.jsonSchemaToOpenAIJsonSchema(items),
-            };
-        }
-        return schema;
-    }
-}
-exports.OpenAIChatModel = OpenAIChatModel;
-// Create role mapper for OpenAI (uses standard mapping)
-const mapRole = (0, core_1.createRoleMapper)(core_1.STANDARD_ROLE_MAP);
-/**
- * @hidden
- */
-async function contentsFromInputMessages(messages) {
-    return Promise.all(messages.map(async (i) => ({
-        role: mapRole(i.role),
-        content: typeof i.content === "string"
-            ? i.content
-            : i.content &&
-                (await Promise.all(i.content.map(async (c) => {
-                    switch (c.type) {
-                        case "text":
-                            return { type: "text", text: c.text };
-                        case "url":
-                            return { type: "image_url", image_url: { url: c.url } };
-                        case "file":
-                            return {
-                                type: "image_url",
-                                image_url: {
-                                    url: `data:${c.mimeType || "image/png"};base64,${c.data}`,
-                                },
-                            };
-                        case "local": {
-                            throw new Error(`Unsupported local file: ${c.path}, it should be converted to base64 at ChatModel`);
-                        }
-                    }
-                }))).filter(type_utils_js_1.isNonNullable),
-        tool_calls: i.toolCalls?.map((i) => ({
-            ...i,
-            function: {
-                ...i.function,
-                arguments: JSON.stringify(i.function.arguments),
-            },
-        })),
-        tool_call_id: i.toolCallId,
-        name: i.name,
-    })));
-}
-/**
- * @hidden
- */
-function toolsFromInputTools(tools, options) {
-    return tools?.length
-        ? tools.map((i) => {
-            const parameters = i.function.parameters;
-            if (options?.addTypeToEmptyParameters && Object.keys(parameters).length === 0) {
-                parameters.type = "object";
-            }
-            return {
-                type: "function",
-                function: {
-                    name: i.function.name,
-                    description: i.function.description,
-                    parameters,
-                },
-            };
-        })
-        : undefined;
-}
-function handleToolCallDelta(toolCalls, call) {
-    toolCalls[call.index] ??= {
-        id: call.id || (0, uuid_1.v7)(),
-        type: "function",
-        function: { name: "", arguments: {} },
-        args: "",
-    };
-    const c = toolCalls[call.index];
-    if (!c)
-        throw new Error("Tool call not found");
-    if (call.type)
-        c.type = call.type;
-    c.function.name = c.function.name + (call.function?.name || "");
-    c.args = c.args.concat(call.function?.arguments || "");
-}
-function handleCompleteToolCall(toolCalls, call) {
-    toolCalls.push({
-        id: call.id || (0, uuid_1.v7)(),
-        type: "function",
-        function: {
-            name: call.function?.name || "",
-            arguments: (0, core_1.safeParseJSON)(call.function?.arguments || "{}"),
-        },
-        args: call.function?.arguments || "",
-    });
-}
-// safeParseJSON is now imported from @aigne/core