@aigne/openai 0.16.16 → 1.74.0-beta

package/README.md

@@ -2,28 +2,28 @@
 
 <p align="center">
   <picture>
-    <source srcset="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/logo-dark.svg" media="(prefers-color-scheme: dark)">
-    <source srcset="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/logo.svg" media="(prefers-color-scheme: light)">
-    <img src="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/logo.svg" alt="AIGNE Logo" width="400" />
+    <source srcset="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/logo-dark.svg" media="(prefers-color-scheme: dark)">
+    <source srcset="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/logo.svg" media="(prefers-color-scheme: light)">
+    <img src="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/logo.svg" alt="AIGNE Logo" width="400" />
   </picture>
 </p>
 
-[![GitHub star chart](https://img.shields.io/github/stars/AIGNE-io/aigne-framework?style=flat-square)](https://star-history.com/#AIGNE-io/aigne-framework)
-[![Open Issues](https://img.shields.io/github/issues-raw/AIGNE-io/aigne-framework?style=flat-square)](https://github.com/AIGNE-io/aigne-framework/issues)
-[![codecov](https://codecov.io/gh/AIGNE-io/aigne-framework/graph/badge.svg?token=DO07834RQL)](https://codecov.io/gh/AIGNE-io/aigne-framework)
+[![GitHub star chart](https://img.shields.io/github/stars/ArcBlock/aigne-framework?style=flat-square)](https://star-history.com/#ArcBlock/aigne-framework)
+[![Open Issues](https://img.shields.io/github/issues-raw/ArcBlock/aigne-framework?style=flat-square)](https://github.com/ArcBlock/aigne-framework/issues)
+[![codecov](https://codecov.io/gh/ArcBlock/aigne-framework/graph/badge.svg?token=DO07834RQL)](https://codecov.io/gh/ArcBlock/aigne-framework)
 [![NPM Version](https://img.shields.io/npm/v/@aigne/openai)](https://www.npmjs.com/package/@aigne/openai)
-[![Elastic-2.0 licensed](https://img.shields.io/npm/l/@aigne/openai)](https://github.com/AIGNE-io/aigne-framework/blob/main/LICENSE.md)
+[![Elastic-2.0 licensed](https://img.shields.io/npm/l/@aigne/openai)](https://github.com/ArcBlock/aigne-framework/blob/main/LICENSE.md)
 
-AIGNE OpenAI SDK for integrating with OpenAI's GPT models and API services within the [AIGNE Framework](https://github.com/AIGNE-io/aigne-framework).
+AIGNE OpenAI SDK for integrating with OpenAI's GPT models and API services within the [AIGNE Framework](https://github.com/ArcBlock/aigne-framework).
 
 ## Introduction
 
 `@aigne/openai` provides a seamless integration between the AIGNE Framework and OpenAI's powerful language models and APIs. This package enables developers to easily leverage OpenAI's GPT models in their AIGNE applications, providing a consistent interface across the framework while taking advantage of OpenAI's advanced AI capabilities.
 
 <picture>
-  <source srcset="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/assets/aigne-openai-dark.png" media="(prefers-color-scheme: dark)">
-  <source srcset="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/assets/aigne-openai.png" media="(prefers-color-scheme: light)">
-  <img src="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/aigne-openai.png" alt="AIGNE Arch" />
+  <source srcset="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/assets/aigne-openai-dark.png" media="(prefers-color-scheme: dark)">
+  <source srcset="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/assets/aigne-openai.png" media="(prefers-color-scheme: light)">
+  <img src="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/aigne-openai.png" alt="AIGNE Arch" />
 </picture>
 
 ## Features

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/index.cjs

@@ -0,0 +1,10 @@
+const require_openai_chat_model = require('./openai-chat-model.cjs');
+const require_openai_image_model = require('./openai-image-model.cjs');
+const require_openai_video_model = require('./openai-video-model.cjs');
+
+exports.OpenAIChatModel = require_openai_chat_model.OpenAIChatModel;
+exports.OpenAIImageModel = require_openai_image_model.OpenAIImageModel;
+exports.OpenAIVideoModel = require_openai_video_model.OpenAIVideoModel;
+exports.contentsFromInputMessages = require_openai_chat_model.contentsFromInputMessages;
+exports.openAIChatModelOptionsSchema = require_openai_chat_model.openAIChatModelOptionsSchema;
+exports.toolsFromInputTools = require_openai_chat_model.toolsFromInputTools;

package/dist/index.d.cts

@@ -0,0 +1,4 @@
+import { OpenAIChatModel, OpenAIChatModelCapabilities, OpenAIChatModelOptions, contentsFromInputMessages, openAIChatModelOptionsSchema, toolsFromInputTools } from "./openai-chat-model.cjs";
+import { OpenAIImageModel, OpenAIImageModelInput, OpenAIImageModelOptions, OpenAIImageModelOutput } from "./openai-image-model.cjs";
+import { OpenAIVideoModel, OpenAIVideoModelInput, OpenAIVideoModelOptions, OpenAIVideoModelOutput } from "./openai-video-model.cjs";
+export { OpenAIChatModel, OpenAIChatModelCapabilities, OpenAIChatModelOptions, OpenAIImageModel, OpenAIImageModelInput, OpenAIImageModelOptions, OpenAIImageModelOutput, OpenAIVideoModel, OpenAIVideoModelInput, OpenAIVideoModelOptions, OpenAIVideoModelOutput, contentsFromInputMessages, openAIChatModelOptionsSchema, toolsFromInputTools };

package/dist/index.d.mts

@@ -0,0 +1,4 @@
+import { OpenAIChatModel, OpenAIChatModelCapabilities, OpenAIChatModelOptions, contentsFromInputMessages, openAIChatModelOptionsSchema, toolsFromInputTools } from "./openai-chat-model.mjs";
+import { OpenAIImageModel, OpenAIImageModelInput, OpenAIImageModelOptions, OpenAIImageModelOutput } from "./openai-image-model.mjs";
+import { OpenAIVideoModel, OpenAIVideoModelInput, OpenAIVideoModelOptions, OpenAIVideoModelOutput } from "./openai-video-model.mjs";
+export { OpenAIChatModel, OpenAIChatModelCapabilities, OpenAIChatModelOptions, OpenAIImageModel, OpenAIImageModelInput, OpenAIImageModelOptions, OpenAIImageModelOutput, OpenAIVideoModel, OpenAIVideoModelInput, OpenAIVideoModelOptions, OpenAIVideoModelOutput, contentsFromInputMessages, openAIChatModelOptionsSchema, toolsFromInputTools };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { OpenAIChatModel, contentsFromInputMessages, openAIChatModelOptionsSchema, toolsFromInputTools } from "./openai-chat-model.mjs";
+import { OpenAIImageModel } from "./openai-image-model.mjs";
+import { OpenAIVideoModel } from "./openai-video-model.mjs";
+
+export { OpenAIChatModel, OpenAIImageModel, OpenAIVideoModel, contentsFromInputMessages, openAIChatModelOptionsSchema, toolsFromInputTools };

package/dist/openai-chat-model.cjs

@@ -0,0 +1,371 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_openai = require('./openai.cjs');
+let _aigne_core = require("@aigne/core");
+let _aigne_core_utils_logger = require("@aigne/core/utils/logger");
+let _aigne_core_utils_model_utils = require("@aigne/core/utils/model-utils");
+let _aigne_core_utils_prompts = require("@aigne/core/utils/prompts");
+let _aigne_core_utils_stream_utils = require("@aigne/core/utils/stream-utils");
+let _aigne_core_utils_type_utils = require("@aigne/core/utils/type-utils");
+let _aigne_uuid = require("@aigne/uuid");
+let zod = require("zod");
+
+//#region src/openai-chat-model.ts
+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
+*/
+const openAIChatModelOptionsSchema = zod.z.object({
+	apiKey: zod.z.string().optional(),
+	baseURL: zod.z.string().optional(),
+	model: zod.z.string().optional(),
+	modelOptions: zod.z.object({
+		model: zod.z.string().optional(),
+		temperature: zod.z.number().optional(),
+		topP: zod.z.number().optional(),
+		frequencyPenalty: zod.z.number().optional(),
+		presencePenalty: zod.z.number().optional(),
+		parallelToolCalls: zod.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}
+*/
+var OpenAIChatModel = class extends _aigne_core.ChatModel {
+	constructor(options) {
+		super();
+		this.options = options;
+		if (options) (0, _aigne_core_utils_type_utils.checkArguments)(this.name, openAIChatModelOptionsSchema, options);
+		const preset = options?.model ? OPENAI_CHAT_MODEL_CAPABILITIES[options.model] : void 0;
+		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 require_openai.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 > 5e3) return "high";
+			if (effort > 1e3) return "medium";
+			if (effort > 500) return "low";
+			if (effort > 0) return "minimal";
+			return;
+		}
+		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 : void 0,
+			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;
+		}
+		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);
+		if (result.toolCalls?.length || result.json) return result;
+		const json = (0, _aigne_core.safeParseJSON)(result.text || "");
+		const validated = this.validateJsonSchema(input.responseFormat.jsonSchema.schema, json, { safe: true });
+		if (validated.success) return {
+			...result,
+			json: validated.data,
+			text: void 0
+		};
+		_aigne_core_utils_logger.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, _aigne_core_utils_model_utils.mergeUsage)(result.usage, output.usage)
+		};
+	}
+	getParallelToolCalls(input, modelOptions) {
+		if (!this.supportsParallelToolCalls) return void 0;
+		if (!input.tools?.length) return void 0;
+		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, _aigne_core_utils_prompts.getJsonOutputPrompt)(input.responseFormat.jsonSchema.schema)
+			});
+		}
+		return messages;
+	}
+	async getRunResponseFormat(input) {
+		if (!this.supportsToolsUseWithJsonSchema && input.tools?.length) return {
+			jsonMode: false,
+			responseFormat: void 0
+		};
+		if (!this.supportsNativeStructuredOutputs) {
+			const jsonMode = input.responseFormat?.type === "json_schema";
+			return {
+				jsonMode,
+				responseFormat: jsonMode ? { type: "json_object" } : void 0
+			};
+		}
+		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: void 0
+		};
+	}
+	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 delta = (chunk.choices?.[0])?.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 !== void 0) 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
+						};
+						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, _aigne_core.safeParseJSON)(text) } } });
+				if (toolCalls.length) controller.enqueue({ delta: { json: { toolCalls: toolCalls.map(({ args, ...c }) => ({
+					...c,
+					function: {
+						...c.function,
+						arguments: args ? (0, _aigne_core.safeParseJSON)(args) : {}
+					}
+				})) } } });
+				if (refusal) controller.error(/* @__PURE__ */ new Error(`Got refusal from LLM: ${refusal}`));
+				controller.close();
+			} catch (error) {
+				controller.error(error);
+			}
+		} });
+		return streaming ? result : await (0, _aigne_core_utils_stream_utils.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);
+					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;
+	}
+};
+const mapRole = (0, _aigne_core.createRoleMapper)(_aigne_core.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(_aigne_core_utils_type_utils.isNonNullable),
+		tool_calls: i.toolCalls?.map((i$1) => ({
+			...i$1,
+			function: {
+				...i$1.function,
+				arguments: JSON.stringify(i$1.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
+			}
+		};
+	}) : void 0;
+}
+function handleToolCallDelta(toolCalls, call) {
+	toolCalls[call.index] ??= {
+		id: call.id || (0, _aigne_uuid.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, _aigne_uuid.v7)(),
+		type: "function",
+		function: {
+			name: call.function?.name || "",
+			arguments: (0, _aigne_core.safeParseJSON)(call.function?.arguments || "{}")
+		},
+		args: call.function?.arguments || ""
+	});
+}
+
+//#endregion
+exports.OpenAIChatModel = OpenAIChatModel;
+exports.contentsFromInputMessages = contentsFromInputMessages;
+exports.openAIChatModelOptionsSchema = openAIChatModelOptionsSchema;
+exports.toolsFromInputTools = toolsFromInputTools;

package/dist/openai-chat-model.d.cts

@@ -0,0 +1,165 @@
+import { AgentInvokeOptions, AgentProcessResult, ChatModel, ChatModelInput, ChatModelInputMessage, ChatModelInputTool, ChatModelOptions, ChatModelOutput } from "@aigne/core";
+import { PromiseOrValue } from "@aigne/core/utils/type-utils";
+import { ClientOptions, OpenAI as OpenAI$1 } from "openai";
+import { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
+import { z } from "zod";
+
+//#region src/openai-chat-model.d.ts
+interface OpenAIChatModelCapabilities {
+  supportsNativeStructuredOutputs: boolean;
+  supportsEndWithSystemMessage: boolean;
+  supportsToolsUseWithJsonSchema: boolean;
+  supportsParallelToolCalls: boolean;
+  supportsToolsEmptyParameters: boolean;
+  supportsToolStreaming: boolean;
+  supportsTemperature: boolean;
+}
+/**
+ * Configuration options for OpenAI Chat Model
+ */
+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
+ */
+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, {
+  baseURL?: string | undefined;
+  apiKey?: string | undefined;
+  model?: string | undefined;
+  modelOptions?: {
+    parallelToolCalls: boolean;
+    model?: string | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    presencePenalty?: number | undefined;
+  } | undefined;
+}, {
+  baseURL?: string | undefined;
+  apiKey?: string | undefined;
+  model?: 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}
+ */
+declare class OpenAIChatModel extends ChatModel {
+  options?: OpenAIChatModelOptions | undefined;
+  constructor(options?: OpenAIChatModelOptions | undefined);
+  /**
+       * @hidden
+       */
+  protected _client?: OpenAI$1;
+  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$1;
+  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
+ */
+declare function contentsFromInputMessages(messages: ChatModelInputMessage[]): Promise<ChatCompletionMessageParam[]>;
+/**
+ * @hidden
+ */
+declare function toolsFromInputTools(tools?: ChatModelInputTool[], options?: {
+  addTypeToEmptyParameters?: boolean;
+}): ChatCompletionTool[] | undefined;
+//#endregion
+export { OpenAIChatModel, OpenAIChatModelCapabilities, OpenAIChatModelOptions, contentsFromInputMessages, openAIChatModelOptionsSchema, toolsFromInputTools };
+//# sourceMappingURL=openai-chat-model.d.cts.map

package/dist/openai-chat-model.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-chat-model.d.cts","names":[],"sources":["../src/openai-chat-model.ts"],"mappings":";;;;;;;UAoCiB,2BAAA;EAAA,+BAAA;EAAA,4BAAA;EAAA,8BAAA;EAAA,yBAAA;EAAA,4BAAA;EAAA,qBAAA;EAAA,mBAAA;AAAA;AAAA;AAkBjB;;AAlBiB,UAkBA,sBAAA,SAA+B,gBAAA;EAAA;;AAwBhD;;;EAxBgD,MAAA;EAAA;;AAwBhD;;;EAxBgD,OAAA;EAAA;;AAwBhD;EAxBgD,aAAA,GAkB9B,OAAA,CAAQ,aAAA;AAAA;AAAA;;;AAAA,cAMb,4BAAA,EAA4B,CAAA,CAAA,SAAA;EAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCzC;;;;;;;;;;;;;;;;cAAa,eAAA,SAAwB,SAAA;EAAA,OAAA,GACG,sBAAA;EAAA,YAAA,OAAA,GAAA,sBAAA;EAAA;;;EAAA,UAAA,OAAA,GAWlB,QAAA;EAAA,UAAA,aAAA;EAAA,UAAA,aAAA;EAAA,UAAA,+BAAA;EAAA,UAAA,8BAAA;EAAA,UAAA,yBAAA;EAAA,UAAA,4BAAA;EAAA,UAAA,qBAAA;EAAA,UAAA,mBAAA;EAAA,IAAA,OAAA,GAWV,QAAA;EAAA,IAAA,WAAA;IAAA,GAAA;IAAA,MAAA;IAAA,KAAA;EAAA;EAAA;;;;;EAAA,QAAA,KAAA,EA6BD,cAAA,EAAA,OAAA,EACE,kBAAA,GACR,cAAA,CAAe,kBAAA,CAAmB,eAAA;EAAA,QAAA,kBAAA;EAAA,QAAA,QAAA;EAAA,QAAA,oBAAA;EAAA,UAAA,eAAA,KAAA,EAkGC,cAAA,GAAiB,OAAA,CAAQ,0BAAA;EAAA,QAAA,oBAAA;EAAA,QAAA,uBAAA;EAAA,QAAA,uBAAA;EAAA;;;;;EAAA,UAAA,iBAAA;EAAA,UAAA,6BAAA,MAAA,EAyNhB,MAAA,oBAA0B,MAAA;AAAA;AAAA;;;AAAA,iBA+CrD,yBAAA,CAAA,QAAA,EACV,qBAAA,KACT,OAAA,CAAQ,0BAAA;AAAA;;;AAAA,iBAmDK,mBAAA,CAAA,KAAA,GACN,kBAAA,IAAA,OAAA;EAAA,wBAAA;AAAA,IAEP,kBAAA"}