@aigne/openai 0.16.16 → 1.74.0-beta

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

@@ -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 { z } from "zod";
+import { ClientOptions, OpenAI as OpenAI$1 } from "openai";
+import { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
+
+//#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.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"openai-chat-model.d.mts","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"}

package/dist/openai-chat-model.mjs

@@ -0,0 +1,368 @@
+import { CustomOpenAI } from "./openai.mjs";
+import { ChatModel, STANDARD_ROLE_MAP, createRoleMapper, safeParseJSON } from "@aigne/core";
+import { logger } from "@aigne/core/utils/logger";
+import { mergeUsage } from "@aigne/core/utils/model-utils";
+import { getJsonOutputPrompt } from "@aigne/core/utils/prompts";
+import { agentResponseStreamToObject } from "@aigne/core/utils/stream-utils";
+import { checkArguments, isNonNullable } from "@aigne/core/utils/type-utils";
+import { v7 } from "@aigne/uuid";
+import { z } from "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 = z.object({
+	apiKey: z.string().optional(),
+	baseURL: z.string().optional(),
+	model: z.string().optional(),
+	modelOptions: z.object({
+		model: z.string().optional(),
+		temperature: z.number().optional(),
+		topP: z.number().optional(),
+		frequencyPenalty: z.number().optional(),
+		presencePenalty: z.number().optional(),
+		parallelToolCalls: 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 ChatModel {
+	constructor(options) {
+		super();
+		this.options = options;
+		if (options) 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 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 = 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
+		};
+		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: 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: 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: safeParseJSON(text) } } });
+				if (toolCalls.length) controller.enqueue({ delta: { json: { toolCalls: toolCalls.map(({ args, ...c }) => ({
+					...c,
+					function: {
+						...c.function,
+						arguments: args ? 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 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 = createRoleMapper(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(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 || 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 || v7(),
+		type: "function",
+		function: {
+			name: call.function?.name || "",
+			arguments: safeParseJSON(call.function?.arguments || "{}")
+		},
+		args: call.function?.arguments || ""
+	});
+}
+
+//#endregion
+export { OpenAIChatModel, contentsFromInputMessages, openAIChatModelOptionsSchema, toolsFromInputTools };
+//# sourceMappingURL=openai-chat-model.mjs.map

package/dist/openai-chat-model.mjs.map

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