@aigne/openai 0.16.16 → 1.74.0-beta

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

@@ -1,55 +0,0 @@
-import { type AgentInvokeOptions, ImageModel, type ImageModelInput, type ImageModelOptions, type ImageModelOutput } from "@aigne/core";
-import { type Camelize } from "@aigne/core/utils/camelize.js";
-import type OpenAI from "openai";
-import type { ClientOptions } from "openai";
-export interface OpenAIImageModelInput extends ImageModelInput, Camelize<Omit<OpenAI.ImageGenerateParams | OpenAI.ImageEditParams, "prompt" | "model" | "n" | "response_format">> {
-}
-export interface OpenAIImageModelOutput extends ImageModelOutput {
-}
-export interface OpenAIImageModelOptions extends ImageModelOptions<OpenAIImageModelInput, OpenAIImageModelOutput> {
-    /**
-     * 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;
-    /**
-     * OpenAI model to use
-     *
-     * Defaults to 'dall-e-2'
-     */
-    model?: string;
-    /**
-     * Additional model options to control behavior
-     */
-    modelOptions?: Omit<Partial<OpenAIImageModelInput>, "model">;
-    /**
-     * Client options for OpenAI API
-     */
-    clientOptions?: Partial<ClientOptions>;
-}
-export declare class OpenAIImageModel extends ImageModel<OpenAIImageModelInput, OpenAIImageModelOutput> {
-    options?: OpenAIImageModelOptions | undefined;
-    constructor(options?: OpenAIImageModelOptions | undefined);
-    protected _client?: OpenAI;
-    protected apiKeyEnvName: string;
-    get client(): OpenAI;
-    get credential(): {
-        url: string | undefined;
-        apiKey: string | undefined;
-        model: string;
-    };
-    get modelOptions(): Omit<Partial<OpenAIImageModelInput>, "model"> | undefined;
-    /**
-     * Process the input and generate a response
-     * @param input The input to process
-     * @returns The generated response
-     */
-    process(input: OpenAIImageModelInput, _options: AgentInvokeOptions): Promise<OpenAIImageModelOutput>;
-}

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

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAIImageModel = void 0;
-const core_1 = require("@aigne/core");
-const camelize_js_1 = require("@aigne/core/utils/camelize.js");
-const type_utils_js_1 = require("@aigne/core/utils/type-utils.js");
-const zod_1 = require("zod");
-const openai_js_1 = require("./openai.js");
-const DEFAULT_MODEL = "dall-e-2";
-const OUTPUT_MIME_TYPE = "image/png";
-const SUPPORTED_PARAMS = {
-    "dall-e-2": ["prompt", "size", "n"],
-    "dall-e-3": ["prompt", "size", "n", "quality", "style", "user"],
-    "gpt-image-1": [
-        "prompt",
-        "size",
-        "background",
-        "moderation",
-        "outputCompression",
-        "outputFormat",
-        "quality",
-        "user",
-        "stream",
-    ],
-};
-const SUPPORT_EDIT_MODELS = ["gpt-image-1"];
-const openAIImageModelInputSchema = core_1.imageModelInputSchema.extend({});
-const openAIImageModelOptionsSchema = 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({}).optional(),
-    clientOptions: zod_1.z.object({}).optional(),
-});
-class OpenAIImageModel extends core_1.ImageModel {
-    options;
-    constructor(options) {
-        super({
-            ...options,
-            inputSchema: openAIImageModelInputSchema,
-            description: options?.description ?? "Draw or edit image by OpenAI image models",
-        });
-        this.options = options;
-        if (options)
-            (0, type_utils_js_1.checkArguments)(this.name, openAIImageModelOptionsSchema, options);
-    }
-    _client;
-    apiKeyEnvName = "OPENAI_API_KEY";
-    get client() {
-        if (this._client)
-            return this._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],
-            model: this.options?.model || DEFAULT_MODEL,
-        };
-    }
-    get modelOptions() {
-        return this.options?.modelOptions;
-    }
-    /**
-     * Process the input and generate a response
-     * @param input The input to process
-     * @returns The generated response
-     */
-    async process(input, _options) {
-        const model = input.modelOptions?.model || this.credential.model;
-        if (input.image?.length && !SUPPORT_EDIT_MODELS.includes(model)) {
-            throw new Error(`Model ${model} does not support image editing`);
-        }
-        const body = {
-            ...(0, camelize_js_1.snakelize)((0, type_utils_js_1.pick)({ ...this.modelOptions, ...input.modelOptions, ...input }, SUPPORTED_PARAMS[model] || SUPPORTED_PARAMS[DEFAULT_MODEL])),
-            model,
-        };
-        const response = input.image?.length
-            ? (await this.client.images.edit({
-                ...body,
-                image: await Promise.all(input.image.map((image) => this.transformFileType("file", image).then((file) => new File([Buffer.from(file.data, "base64")], file.filename || "image.png", {
-                    type: file.mimeType,
-                })))),
-            }, { stream: false }))
-            : (await this.client.images.generate({ ...body }, { stream: false }));
-        return {
-            images: (response.data ?? []).map((image) => {
-                if (image.url)
-                    return { type: "url", url: image.url, mimeType: OUTPUT_MIME_TYPE };
-                if (image.b64_json)
-                    return { type: "file", data: image.b64_json, mimeType: OUTPUT_MIME_TYPE };
-                throw new Error("Image response does not contain a valid URL or base64 data");
-            }),
-            usage: {
-                inputTokens: response.usage?.input_tokens || 0,
-                outputTokens: response.usage?.output_tokens || 0,
-            },
-            model,
-        };
-    }
-}
-exports.OpenAIImageModel = OpenAIImageModel;

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

@@ -1,92 +0,0 @@
-import { type AgentInvokeOptions, VideoModel, type VideoModelInput, type VideoModelOptions, type VideoModelOutput } from "@aigne/core";
-import type OpenAI from "openai";
-import type { ClientOptions } from "openai";
-/**
- * Input options for OpenAI Video Model
- */
-export interface OpenAIVideoModelInput extends VideoModelInput {
-    /**
-     * Sora model to use for video generation
-     *
-     * - `sora-2`: Standard version, lower cost
-     * - `sora-2-pro`: Pro version, higher quality
-     *
-     * @default "sora-2"
-     */
-    model?: "sora-2" | "sora-2-pro";
-    /**
-     * Video resolution (width x height)
-     *
-     * - `720x1280`: Vertical video (9:16)
-     * - `1280x720`: Horizontal video (16:9)
-     * - `1024x1792`: Vertical video (9:16, higher resolution)
-     * - `1792x1024`: Horizontal video (16:9, higher resolution)
-     */
-    size?: "720x1280" | "1280x720" | "1024x1792" | "1792x1024";
-    /**
-     * Video duration in seconds
-     *
-     * @default "4"
-     */
-    seconds?: "4" | "8" | "12";
-}
-/**
- * Output from OpenAI Video Model
- */
-export interface OpenAIVideoModelOutput extends VideoModelOutput {
-}
-/**
- * Configuration options for OpenAI Video Model
- */
-export interface OpenAIVideoModelOptions extends VideoModelOptions<OpenAIVideoModelInput, OpenAIVideoModelOutput> {
-    /**
-     * 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;
-    /**
-     * OpenAI model to use
-     *
-     * Defaults to 'sora-2'
-     */
-    model?: string;
-    /**
-     * Additional model options to control behavior
-     */
-    modelOptions?: Omit<Partial<OpenAIVideoModelInput>, "model">;
-    /**
-     * Client options for OpenAI API
-     */
-    clientOptions?: Partial<ClientOptions>;
-    /**
-     * Polling interval in milliseconds for checking video generation status
-     *
-     * Defaults to 2000ms (2 seconds)
-     */
-    pollingInterval?: number;
-}
-export declare class OpenAIVideoModel extends VideoModel<OpenAIVideoModelInput, OpenAIVideoModelOutput> {
-    options?: OpenAIVideoModelOptions | undefined;
-    constructor(options?: OpenAIVideoModelOptions | undefined);
-    /**
-     * @hidden
-     */
-    protected _client?: OpenAI;
-    protected apiKeyEnvName: string;
-    get client(): OpenAI;
-    get credential(): {
-        url: string | undefined;
-        apiKey: string | undefined;
-        model: string;
-    };
-    get modelOptions(): Omit<Partial<OpenAIVideoModelInput>, "model"> | undefined;
-    downloadToFile(videoId: string): Promise<string>;
-    process(input: OpenAIVideoModelInput, _options: AgentInvokeOptions): Promise<OpenAIVideoModelOutput>;
-}

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

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAIVideoModel = void 0;
-const core_1 = require("@aigne/core");
-const logger_js_1 = require("@aigne/core/utils/logger.js");
-const type_utils_js_1 = require("@aigne/core/utils/type-utils.js");
-const zod_1 = require("zod");
-const openai_js_1 = require("./openai.js");
-const DEFAULT_MODEL = "sora-2";
-const DEFAULT_SECONDS = 4;
-const openAIVideoModelInputSchema = core_1.videoModelInputSchema.extend({
-    model: zod_1.z.enum(["sora-2", "sora-2-pro"]).optional(),
-    seconds: zod_1.z.enum(["4", "8", "12"]).optional(),
-    size: zod_1.z.enum(["720x1280", "1280x720", "1024x1792", "1792x1024"]).optional(),
-});
-const openAIVideoModelOptionsSchema = 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({}).optional(),
-    clientOptions: zod_1.z.object({}).optional(),
-    pollingInterval: zod_1.z.number().optional(),
-});
-class OpenAIVideoModel extends core_1.VideoModel {
-    options;
-    constructor(options) {
-        super({
-            ...options,
-            description: options?.description ?? "Generate videos using OpenAI Sora models",
-            inputSchema: openAIVideoModelInputSchema,
-        });
-        this.options = options;
-        if (options)
-            (0, type_utils_js_1.checkArguments)(this.name, openAIVideoModelOptionsSchema, options);
-    }
-    /**
-     * @hidden
-     */
-    _client;
-    apiKeyEnvName = "OPENAI_API_KEY";
-    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],
-            model: this.options?.model || DEFAULT_MODEL,
-        };
-    }
-    get modelOptions() {
-        return this.options?.modelOptions;
-    }
-    async downloadToFile(videoId) {
-        logger_js_1.logger.debug("Downloading video content...");
-        const content = await this.client.videos.downloadContent(videoId);
-        const arrayBuffer = await content.arrayBuffer();
-        const buffer = Buffer.from(arrayBuffer);
-        return buffer.toString("base64");
-    }
-    async process(input, _options) {
-        const model = input.model ?? input.modelOptions?.model ?? this.credential.model;
-        const createParams = {
-            model: model,
-            prompt: input.prompt,
-        };
-        if (input.seconds)
-            createParams.seconds = input.seconds;
-        if (input.size)
-            createParams.size = input.size;
-        if (input.image) {
-            createParams.input_reference = await this.transformFileType("file", input.image).then((file) => new File([Buffer.from(file.data, "base64")], file.filename || "image.png", {
-                type: file.mimeType,
-            }));
-        }
-        let video = await this.client.videos.create(createParams);
-        logger_js_1.logger.debug(`Video generation started: ${video.id}`);
-        const pollingInterval = this.options?.pollingInterval ?? 2000;
-        while (video.status === "in_progress" || video.status === "queued") {
-            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
-            video = await this.client.videos.retrieve(video.id);
-            const progress = video.progress ?? 0;
-            const statusText = video.status === "queued" ? "Queued" : "Processing";
-            logger_js_1.logger.debug(`${statusText}: ${progress.toFixed(1)}%`);
-        }
-        if (video.status === "failed") {
-            throw new Error(`Video generation failed: ${video.error?.message || "Unknown error"}`);
-        }
-        if (video.status !== "completed") {
-            throw new Error(`Unexpected video status: ${video.status}`);
-        }
-        return {
-            videos: [
-                {
-                    type: "file",
-                    data: await this.downloadToFile(video.id),
-                    mimeType: "video/mp4",
-                    filename: `${video.id}.mp4`,
-                },
-            ],
-            usage: {
-                inputTokens: 0,
-                outputTokens: 0,
-            },
-            model,
-            seconds: input.seconds ? parseInt(input.seconds, 10) : DEFAULT_SECONDS,
-        };
-    }
-}
-exports.OpenAIVideoModel = OpenAIVideoModel;

package/lib/cjs/openai.d.ts

@@ -1,4 +0,0 @@
-import OpenAI, { type APIError } from "openai";
-export declare class CustomOpenAI extends OpenAI {
-    protected makeStatusError(status: number, error: object, message: string | undefined, headers: Headers): APIError;
-}

package/lib/cjs/openai.js

@@ -1,17 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomOpenAI = void 0;
-const openai_1 = __importDefault(require("openai"));
-// Use a custom OpenAI client to handle API errors for better error messages
-class CustomOpenAI extends openai_1.default {
-    makeStatusError(status, error, message, headers) {
-        if (!("error" in error) || typeof error.error !== "string") {
-            message = JSON.stringify(error);
-        }
-        return super.makeStatusError(status, error, message, headers);
-    }
-}
-exports.CustomOpenAI = CustomOpenAI;

package/lib/cjs/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

package/lib/dts/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/dts/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/dts/openai-image-model.d.ts

@@ -1,55 +0,0 @@
-import { type AgentInvokeOptions, ImageModel, type ImageModelInput, type ImageModelOptions, type ImageModelOutput } from "@aigne/core";
-import { type Camelize } from "@aigne/core/utils/camelize.js";
-import type OpenAI from "openai";
-import type { ClientOptions } from "openai";
-export interface OpenAIImageModelInput extends ImageModelInput, Camelize<Omit<OpenAI.ImageGenerateParams | OpenAI.ImageEditParams, "prompt" | "model" | "n" | "response_format">> {
-}
-export interface OpenAIImageModelOutput extends ImageModelOutput {
-}
-export interface OpenAIImageModelOptions extends ImageModelOptions<OpenAIImageModelInput, OpenAIImageModelOutput> {
-    /**
-     * 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;
-    /**
-     * OpenAI model to use
-     *
-     * Defaults to 'dall-e-2'
-     */
-    model?: string;
-    /**
-     * Additional model options to control behavior
-     */
-    modelOptions?: Omit<Partial<OpenAIImageModelInput>, "model">;
-    /**
-     * Client options for OpenAI API
-     */
-    clientOptions?: Partial<ClientOptions>;
-}
-export declare class OpenAIImageModel extends ImageModel<OpenAIImageModelInput, OpenAIImageModelOutput> {
-    options?: OpenAIImageModelOptions | undefined;
-    constructor(options?: OpenAIImageModelOptions | undefined);
-    protected _client?: OpenAI;
-    protected apiKeyEnvName: string;
-    get client(): OpenAI;
-    get credential(): {
-        url: string | undefined;
-        apiKey: string | undefined;
-        model: string;
-    };
-    get modelOptions(): Omit<Partial<OpenAIImageModelInput>, "model"> | undefined;
-    /**
-     * Process the input and generate a response
-     * @param input The input to process
-     * @returns The generated response
-     */
-    process(input: OpenAIImageModelInput, _options: AgentInvokeOptions): Promise<OpenAIImageModelOutput>;
-}