@core-ai/openai 0.14.0 → 0.15.0

package/dist/chunk-YORO2XQ3.js

@@ -0,0 +1,1852 @@
+// src/model-capabilities.ts
+import {
+  stripModelDateSuffix
+} from "@core-ai/core-ai";
+var STANDARD_EFFORTS = [
+  "low",
+  "medium",
+  "high"
+];
+var MAX_EFFORTS = [
+  "low",
+  "medium",
+  "high",
+  "max"
+];
+var MINIMAL_EFFORTS = [
+  "minimal",
+  "low",
+  "medium",
+  "high"
+];
+var PRO_EFFORTS = [
+  "medium",
+  "high",
+  "max"
+];
+var HIGH_EFFORT = ["high"];
+function createCapabilities(supportedEfforts, restrictsSamplingParams, maxTokensParameter = "max_completion_tokens") {
+  return {
+    reasoning: {
+      supported: true,
+      supportedEfforts,
+      restrictsSamplingParams
+    },
+    chatCompletions: {
+      maxTokensParameter
+    }
+  };
+}
+var DEFAULT_CAPABILITIES = createCapabilities(STANDARD_EFFORTS, false);
+var UNKNOWN_MODEL_CAPABILITIES = createCapabilities(
+  STANDARD_EFFORTS,
+  false,
+  "max_tokens"
+);
+var SAMPLING_RESTRICTED_STANDARD_CAPABILITIES = createCapabilities(
+  STANDARD_EFFORTS,
+  true
+);
+var GPT_5_MAX_REASONING_CAPABILITIES = createCapabilities(MAX_EFFORTS, true);
+var GPT_5_MINIMAL_REASONING_CAPABILITIES = createCapabilities(
+  MINIMAL_EFFORTS,
+  true
+);
+var GPT_5_PRO_REASONING_CAPABILITIES = createCapabilities(PRO_EFFORTS, true);
+var GPT_5_HIGH_REASONING_CAPABILITIES = createCapabilities(HIGH_EFFORT, true);
+var NO_REASONING_EFFORT_CAPABILITIES = {
+  reasoning: {
+    supported: false,
+    supportedEfforts: [],
+    restrictsSamplingParams: false
+  },
+  chatCompletions: {
+    maxTokensParameter: "max_completion_tokens"
+  }
+};
+var O_SERIES_MAX_REASONING_CAPABILITIES = createCapabilities(
+  MAX_EFFORTS,
+  false
+);
+var MODEL_CAPABILITIES = {
+  "gpt-5.6-sol": GPT_5_MAX_REASONING_CAPABILITIES,
+  "gpt-5.6-terra": SAMPLING_RESTRICTED_STANDARD_CAPABILITIES,
+  "gpt-5.6-luna": GPT_5_MINIMAL_REASONING_CAPABILITIES,
+  "gpt-5.5": GPT_5_MAX_REASONING_CAPABILITIES,
+  "gpt-5.5-pro": GPT_5_PRO_REASONING_CAPABILITIES,
+  "gpt-5.4": GPT_5_MAX_REASONING_CAPABILITIES,
+  "gpt-5.4-pro": GPT_5_PRO_REASONING_CAPABILITIES,
+  "gpt-5.4-mini": GPT_5_MAX_REASONING_CAPABILITIES,
+  "gpt-5.4-nano": GPT_5_MAX_REASONING_CAPABILITIES,
+  "gpt-5.3-codex": GPT_5_MAX_REASONING_CAPABILITIES,
+  "gpt-5.2": GPT_5_MAX_REASONING_CAPABILITIES,
+  "gpt-5.2-codex": GPT_5_MAX_REASONING_CAPABILITIES,
+  "gpt-5.2-pro": GPT_5_MAX_REASONING_CAPABILITIES,
+  "gpt-5.1-codex": GPT_5_MAX_REASONING_CAPABILITIES,
+  "gpt-5.1-codex-max": GPT_5_MAX_REASONING_CAPABILITIES,
+  "gpt-5.1-codex-mini": GPT_5_MAX_REASONING_CAPABILITIES,
+  "gpt-5.1": SAMPLING_RESTRICTED_STANDARD_CAPABILITIES,
+  "gpt-5": GPT_5_MINIMAL_REASONING_CAPABILITIES,
+  "gpt-5-mini": GPT_5_MINIMAL_REASONING_CAPABILITIES,
+  "gpt-5-nano": GPT_5_MINIMAL_REASONING_CAPABILITIES,
+  "gpt-5-pro": GPT_5_HIGH_REASONING_CAPABILITIES,
+  "gpt-5-codex": GPT_5_MAX_REASONING_CAPABILITIES,
+  "o3-pro": O_SERIES_MAX_REASONING_CAPABILITIES,
+  o3: DEFAULT_CAPABILITIES,
+  "o3-mini": DEFAULT_CAPABILITIES,
+  "o4-mini": DEFAULT_CAPABILITIES,
+  o1: DEFAULT_CAPABILITIES,
+  "o1-mini": NO_REASONING_EFFORT_CAPABILITIES
+};
+var OPENAI_REASONING_EFFORT_MAP = {
+  minimal: "minimal",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  max: "xhigh"
+};
+function getOpenAIModelCapabilities(modelId) {
+  const normalizedModelId = normalizeModelId(modelId);
+  return MODEL_CAPABILITIES[normalizedModelId] ?? UNKNOWN_MODEL_CAPABILITIES;
+}
+function normalizeModelId(modelId) {
+  return stripModelDateSuffix(modelId);
+}
+function toOpenAIReasoningEffort(effort) {
+  return OPENAI_REASONING_EFFORT_MAP[effort];
+}
+
+// src/provider-options.ts
+import { z } from "zod";
+var openaiResponsesGenerateProviderOptionsSchema = z.object({
+  store: z.boolean().optional(),
+  serviceTier: z.enum(["auto", "default", "flex", "scale", "priority"]).optional(),
+  include: z.array(z.string()).optional(),
+  parallelToolCalls: z.boolean().optional(),
+  user: z.string().optional()
+}).strict();
+var openaiChatGenerateProviderOptionsSchema = openaiResponsesGenerateProviderOptionsSchema.omit({
+  include: true
+}).extend({
+  stopSequences: z.array(z.string()).optional(),
+  frequencyPenalty: z.number().optional(),
+  presencePenalty: z.number().optional(),
+  seed: z.number().int().optional()
+}).strict();
+var openaiEmbedProviderOptionsSchema = z.object({
+  encodingFormat: z.enum(["float", "base64"]).optional(),
+  user: z.string().optional()
+}).strict();
+var openaiImageProviderOptionsSchema = z.object({
+  background: z.enum(["transparent", "opaque", "auto"]).optional(),
+  moderation: z.enum(["low", "auto"]).optional(),
+  outputCompression: z.number().int().min(0).max(100).optional(),
+  outputFormat: z.enum(["png", "jpeg", "webp"]).optional(),
+  quality: z.enum(["standard", "hd", "low", "medium", "high", "auto"]).optional(),
+  responseFormat: z.enum(["url", "b64_json"]).optional(),
+  style: z.enum(["vivid", "natural"]).optional(),
+  user: z.string().optional()
+}).strict();
+function parseOpenAIProviderOptions(providerOptions, schema) {
+  const rawOptions = providerOptions?.openai;
+  if (rawOptions === void 0) {
+    return void 0;
+  }
+  return schema.parse(rawOptions);
+}
+function parseOpenAIResponsesGenerateProviderOptions(providerOptions) {
+  return parseOpenAIProviderOptions(
+    providerOptions,
+    openaiResponsesGenerateProviderOptionsSchema
+  );
+}
+function parseOpenAIChatGenerateProviderOptions(providerOptions) {
+  return parseOpenAIProviderOptions(
+    providerOptions,
+    openaiChatGenerateProviderOptionsSchema
+  );
+}
+function parseOpenAIEmbedProviderOptions(providerOptions) {
+  return parseOpenAIProviderOptions(
+    providerOptions,
+    openaiEmbedProviderOptionsSchema
+  );
+}
+function parseOpenAIImageProviderOptions(providerOptions) {
+  return parseOpenAIProviderOptions(
+    providerOptions,
+    openaiImageProviderOptionsSchema
+  );
+}
+var openaiResponsesProviderOptionsSchema = openaiResponsesGenerateProviderOptionsSchema;
+var openaiCompatProviderOptionsSchema = openaiChatGenerateProviderOptionsSchema;
+var openaiCompatGenerateProviderOptionsSchema = openaiChatGenerateProviderOptionsSchema;
+
+// src/chat-completions/chat-model.ts
+import { createObjectStream, createChatStream } from "@core-ai/core-ai";
+
+// src/chat-completions/chat-adapter.ts
+import { clampReasoningEffort } from "@core-ai/core-ai";
+
+// src/shared/tools.ts
+import { zodSchemaToJsonSchema } from "@core-ai/core-ai";
+function convertTools(tools) {
+  return Object.values(tools).map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: zodSchemaToJsonSchema(tool.parameters)
+    }
+  }));
+}
+function convertToolChoice(choice) {
+  if (typeof choice === "string") {
+    return choice;
+  }
+  return {
+    type: "function",
+    function: {
+      name: choice.toolName
+    }
+  };
+}
+
+// src/shared/utils.ts
+import { ValidationError } from "@core-ai/core-ai";
+function safeParseJsonObject(json) {
+  try {
+    const parsed = JSON.parse(json);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function validateOpenAIReasoningConfig(modelId, options) {
+  if (!options.reasoning) {
+    return;
+  }
+  const capabilities = getOpenAIModelCapabilities(modelId);
+  if (!capabilities.reasoning.restrictsSamplingParams) {
+    return;
+  }
+  const restrictedSamplingParams = [
+    { name: "temperature", value: options.temperature },
+    { name: "topP", value: options.topP }
+  ];
+  for (const { name, value } of restrictedSamplingParams) {
+    if (value === void 0) {
+      continue;
+    }
+    throw new ValidationError(
+      `OpenAI model "${modelId}" does not support ${name} when reasoning is enabled`,
+      void 0,
+      "openai"
+    );
+  }
+}
+
+// src/chat-completions/compatibility.ts
+function extractCompatibleReasoningText(source) {
+  const { reasoning_content, reasoning } = source;
+  if (typeof reasoning_content === "string" && reasoning_content.length > 0) {
+    return reasoning_content;
+  }
+  if (typeof reasoning === "string" && reasoning.length > 0) {
+    return reasoning;
+  }
+  return void 0;
+}
+
+// src/chat-completions/chat-adapter.ts
+function convertMessages(messages) {
+  return messages.map(convertMessage);
+}
+function convertMessage(message) {
+  if (message.role === "system") {
+    return {
+      role: "system",
+      content: message.content
+    };
+  }
+  if (message.role === "user") {
+    return {
+      role: "user",
+      content: typeof message.content === "string" ? message.content : message.content.map(convertUserContentPart)
+    };
+  }
+  if (message.role === "assistant") {
+    const text = message.parts.flatMap((part) => {
+      if (part.type === "text") return [part.text];
+      if (part.type === "reasoning" && part.text.length > 0) {
+        return [`<thinking>${part.text}</thinking>`];
+      }
+      return [];
+    }).join("\n\n");
+    const toolCalls = message.parts.flatMap(
+      (part) => part.type === "tool-call" ? [part.toolCall] : []
+    );
+    return {
+      role: "assistant",
+      content: text.length > 0 ? text : null,
+      ...toolCalls.length > 0 ? {
+        tool_calls: toolCalls.map((toolCall) => ({
+          id: toolCall.id,
+          type: "function",
+          function: {
+            name: toolCall.name,
+            arguments: JSON.stringify(toolCall.arguments)
+          }
+        }))
+      } : {}
+    };
+  }
+  return {
+    role: "tool",
+    tool_call_id: message.toolCallId,
+    content: message.content
+  };
+}
+function convertUserContentPart(part) {
+  if (part.type === "text") {
+    return {
+      type: "text",
+      text: part.text
+    };
+  }
+  if (part.type === "image") {
+    const url = part.source.type === "url" ? part.source.url : `data:${part.source.mediaType};base64,${part.source.data}`;
+    return {
+      type: "image_url",
+      image_url: {
+        url
+      }
+    };
+  }
+  return {
+    type: "file",
+    file: {
+      file_data: part.data,
+      ...part.filename ? { filename: part.filename } : {}
+    }
+  };
+}
+function createGenerateRequest(modelId, options, adapterOptions = {}) {
+  return createRequest(modelId, options, false, adapterOptions);
+}
+function createStreamRequest(modelId, options, adapterOptions = {}) {
+  return createRequest(modelId, options, true, adapterOptions);
+}
+function createRequest(modelId, options, stream, adapterOptions) {
+  const openaiOptions = parseOpenAIChatGenerateProviderOptions(
+    options.providerOptions
+  );
+  const structuredOutputFormat = options.structuredOutputFormat;
+  return {
+    ...createRequestBase(modelId, options, adapterOptions),
+    ...stream ? {
+      stream: true,
+      stream_options: {
+        include_usage: true
+      }
+    } : {},
+    ...structuredOutputFormat ? {
+      response_format: {
+        type: "json_schema",
+        json_schema: {
+          name: structuredOutputFormat.name,
+          ...structuredOutputFormat.description ? {
+            description: structuredOutputFormat.description
+          } : {},
+          strict: structuredOutputFormat.strict,
+          schema: structuredOutputFormat.schema
+        }
+      }
+    } : {},
+    ...mapOpenAIProviderOptionsToRequestFields(openaiOptions)
+  };
+}
+function createRequestBase(modelId, options, adapterOptions) {
+  validateOpenAIReasoningConfig(modelId, options);
+  const reasoningFields = mapReasoningToRequestFields(modelId, options);
+  return {
+    model: modelId,
+    messages: convertMessages(options.messages),
+    ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
+    ...options.toolChoice ? { tool_choice: convertToolChoice(options.toolChoice) } : {},
+    ...reasoningFields,
+    ...mapSamplingToRequestFields(modelId, options, adapterOptions)
+  };
+}
+function mapSamplingToRequestFields(modelId, options, adapterOptions) {
+  const maxTokensParameter = adapterOptions.maxTokensParameter ?? getOpenAIModelCapabilities(modelId).chatCompletions.maxTokensParameter;
+  return {
+    ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+    ...options.maxTokens !== void 0 ? maxTokensParameter === "max_completion_tokens" ? { max_completion_tokens: options.maxTokens } : { max_tokens: options.maxTokens } : {},
+    ...options.topP !== void 0 ? { top_p: options.topP } : {}
+  };
+}
+function mapOpenAIProviderOptionsToRequestFields(options) {
+  return {
+    ...options?.store !== void 0 ? { store: options.store } : {},
+    ...options?.serviceTier !== void 0 ? { service_tier: options.serviceTier } : {},
+    ...options?.parallelToolCalls !== void 0 ? { parallel_tool_calls: options.parallelToolCalls } : {},
+    ...options?.user !== void 0 ? { user: options.user } : {},
+    ...options?.stopSequences ? { stop: options.stopSequences } : {},
+    ...options?.frequencyPenalty !== void 0 ? { frequency_penalty: options.frequencyPenalty } : {},
+    ...options?.presencePenalty !== void 0 ? { presence_penalty: options.presencePenalty } : {},
+    ...options?.seed !== void 0 ? { seed: options.seed } : {}
+  };
+}
+function mapGenerateResponse(response, adapterOptions = {}) {
+  const firstChoice = response.choices[0];
+  if (!firstChoice) {
+    return {
+      parts: [],
+      content: null,
+      reasoning: null,
+      toolCalls: [],
+      finishReason: "unknown",
+      usage: {
+        inputTokens: 0,
+        outputTokens: 0,
+        inputTokenDetails: {
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0
+        },
+        outputTokenDetails: {}
+      }
+    };
+  }
+  const reasoningTokens = response.usage?.completion_tokens_details?.reasoning_tokens;
+  const content = extractTextContent(firstChoice.message.content);
+  const reasoning = adapterOptions.compatibility ? extractCompatibleReasoningText(firstChoice.message) ?? null : null;
+  const toolCalls = parseToolCalls(firstChoice.message.tool_calls);
+  const parts = createAssistantParts(reasoning, content, toolCalls);
+  return {
+    parts,
+    content,
+    reasoning,
+    toolCalls,
+    finishReason: mapFinishReason(firstChoice.finish_reason),
+    usage: {
+      inputTokens: response.usage?.prompt_tokens ?? 0,
+      outputTokens: response.usage?.completion_tokens ?? 0,
+      inputTokenDetails: {
+        cacheReadTokens: response.usage?.prompt_tokens_details?.cached_tokens ?? 0,
+        cacheWriteTokens: 0
+      },
+      outputTokenDetails: {
+        ...reasoningTokens !== void 0 ? { reasoningTokens } : {}
+      }
+    }
+  };
+}
+function parseToolCalls(calls) {
+  if (!calls) {
+    return [];
+  }
+  return calls.flatMap((toolCall) => {
+    if (toolCall.type !== "function") {
+      return [];
+    }
+    return [mapFunctionToolCall(toolCall)];
+  });
+}
+function mapFunctionToolCall(toolCall) {
+  return {
+    id: toolCall.id,
+    name: toolCall.function.name,
+    arguments: safeParseJsonObject(toolCall.function.arguments)
+  };
+}
+function mapFinishReason(reason) {
+  if (reason === "stop") {
+    return "stop";
+  }
+  if (reason === "length") {
+    return "length";
+  }
+  if (reason === "tool_calls" || reason === "function_call") {
+    return "tool-calls";
+  }
+  if (reason === "content_filter") {
+    return "content-filter";
+  }
+  return "unknown";
+}
+async function* transformStream(stream, adapterOptions = {}) {
+  const bufferedToolCalls = /* @__PURE__ */ new Map();
+  const emittedToolCalls = /* @__PURE__ */ new Set();
+  let finishReason = "unknown";
+  let textOpen = false;
+  let reasoningOpen = false;
+  let usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    inputTokenDetails: {
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0
+    },
+    outputTokenDetails: {}
+  };
+  const startText = function* () {
+    if (textOpen) {
+      return;
+    }
+    textOpen = true;
+    yield { type: "text-start" };
+  };
+  const closeText = function* () {
+    if (!textOpen) {
+      return;
+    }
+    textOpen = false;
+    yield { type: "text-end" };
+  };
+  const startReasoning = function* () {
+    if (reasoningOpen) {
+      return;
+    }
+    reasoningOpen = true;
+    yield { type: "reasoning-start" };
+  };
+  const closeReasoning = function* () {
+    if (!reasoningOpen) {
+      return;
+    }
+    reasoningOpen = false;
+    yield { type: "reasoning-end" };
+  };
+  for await (const chunk of stream) {
+    if (chunk.usage) {
+      const reasoningTokens = chunk.usage.completion_tokens_details?.reasoning_tokens;
+      usage = {
+        inputTokens: chunk.usage.prompt_tokens ?? 0,
+        outputTokens: chunk.usage.completion_tokens ?? 0,
+        inputTokenDetails: {
+          cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens ?? 0,
+          cacheWriteTokens: 0
+        },
+        outputTokenDetails: {
+          ...reasoningTokens !== void 0 ? { reasoningTokens } : {}
+        }
+      };
+    }
+    const choice = chunk.choices[0];
+    if (!choice) {
+      continue;
+    }
+    const reasoningDelta = adapterOptions.compatibility ? extractCompatibleReasoningText(choice.delta) : void 0;
+    if (reasoningDelta !== void 0) {
+      yield* closeText();
+      yield* startReasoning();
+      yield {
+        type: "reasoning-delta",
+        text: reasoningDelta
+      };
+    }
+    if (choice.delta.content) {
+      yield* closeReasoning();
+      yield* startText();
+      yield {
+        type: "text-delta",
+        text: choice.delta.content
+      };
+    }
+    if (choice.delta.tool_calls) {
+      yield* closeReasoning();
+      yield* closeText();
+      for (const partialToolCall of choice.delta.tool_calls) {
+        const current = bufferedToolCalls.get(
+          partialToolCall.index
+        ) ?? {
+          id: partialToolCall.id ?? `tool-${partialToolCall.index}`,
+          name: partialToolCall.function?.name ?? "",
+          arguments: ""
+        };
+        const wasNew = !bufferedToolCalls.has(partialToolCall.index);
+        if (partialToolCall.id) {
+          current.id = partialToolCall.id;
+        }
+        if (partialToolCall.function?.name) {
+          current.name = partialToolCall.function.name;
+        }
+        if (partialToolCall.function?.arguments) {
+          current.arguments += partialToolCall.function.arguments;
+          yield {
+            type: "tool-call-delta",
+            toolCallId: current.id,
+            argumentsDelta: partialToolCall.function.arguments
+          };
+        }
+        bufferedToolCalls.set(partialToolCall.index, current);
+        if (wasNew) {
+          yield {
+            type: "tool-call-start",
+            toolCallId: current.id,
+            toolName: current.name
+          };
+        }
+      }
+    }
+    if (choice.finish_reason) {
+      finishReason = mapFinishReason(choice.finish_reason);
+    }
+    if (finishReason === "tool-calls") {
+      yield* closeReasoning();
+      yield* closeText();
+      for (const toolCall of bufferedToolCalls.values()) {
+        if (emittedToolCalls.has(toolCall.id)) {
+          continue;
+        }
+        emittedToolCalls.add(toolCall.id);
+        yield {
+          type: "tool-call-end",
+          toolCall: {
+            id: toolCall.id,
+            name: toolCall.name,
+            arguments: safeParseJsonObject(toolCall.arguments)
+          }
+        };
+      }
+    }
+  }
+  yield* closeReasoning();
+  yield* closeText();
+  yield {
+    type: "finish",
+    finishReason,
+    usage
+  };
+}
+function mapReasoningToRequestFields(modelId, options) {
+  if (!options.reasoning) {
+    return {};
+  }
+  const capabilities = getOpenAIModelCapabilities(modelId);
+  if (!capabilities.reasoning.supported) {
+    return {};
+  }
+  const clampedEffort = clampReasoningEffort(
+    options.reasoning.effort,
+    capabilities.reasoning.supportedEfforts
+  );
+  return {
+    reasoning_effort: toOpenAIReasoningEffort(clampedEffort)
+  };
+}
+function createAssistantParts(reasoning, content, toolCalls) {
+  const parts = [];
+  if (reasoning) {
+    parts.push({
+      type: "reasoning",
+      text: reasoning
+    });
+  }
+  if (content) {
+    parts.push({
+      type: "text",
+      text: content
+    });
+  }
+  for (const toolCall of toolCalls) {
+    parts.push({
+      type: "tool-call",
+      toolCall
+    });
+  }
+  return parts;
+}
+function extractTextContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return null;
+  }
+  const text = content.flatMap((item) => {
+    if (!item || typeof item !== "object") {
+      return [];
+    }
+    const textValue = item.text;
+    return typeof textValue === "string" ? [textValue] : [];
+  }).join("");
+  return text.length > 0 ? text : null;
+}
+
+// src/openai-error.ts
+import { APIError, APIUserAbortError } from "openai";
+import { AbortedError, ProviderError } from "@core-ai/core-ai";
+function isOpenAIAbortError(error) {
+  return error instanceof APIUserAbortError || error instanceof Error && error.name === "AbortError";
+}
+function wrapOpenAIError(error, provider = "openai") {
+  if (isOpenAIAbortError(error)) {
+    return new AbortedError(error, provider);
+  }
+  if (error instanceof APIError) {
+    return new ProviderError(
+      error.message,
+      provider,
+      error.status,
+      error
+    );
+  }
+  return new ProviderError(
+    error instanceof Error ? error.message : String(error),
+    provider,
+    void 0,
+    error
+  );
+}
+
+// src/shared/structured-output.ts
+import { zodTextFormat } from "openai/helpers/zod";
+import {
+  StructuredOutputNoObjectGeneratedError,
+  StructuredOutputParseError,
+  StructuredOutputValidationError
+} from "@core-ai/core-ai";
+var DEFAULT_STRUCTURED_OUTPUT_NAME = "core_ai_generate_object";
+var DEFAULT_STRUCTURED_OUTPUT_DESCRIPTION = "Return a JSON object that matches the requested schema.";
+function getStructuredOutputName(options) {
+  return options.schemaName?.trim() || DEFAULT_STRUCTURED_OUTPUT_NAME;
+}
+function createStructuredOutputRequestOptions(options, mode = "native") {
+  const baseOptions = {
+    messages: options.messages,
+    reasoning: options.reasoning,
+    temperature: options.temperature,
+    maxTokens: options.maxTokens,
+    topP: options.topP,
+    providerOptions: options.providerOptions,
+    signal: options.signal
+  };
+  if (mode === "tool") {
+    const name = getStructuredOutputName(options);
+    return {
+      ...baseOptions,
+      tools: {
+        structured_output: {
+          name,
+          description: options.schemaDescription ?? DEFAULT_STRUCTURED_OUTPUT_DESCRIPTION,
+          parameters: options.schema
+        }
+      },
+      toolChoice: {
+        type: "tool",
+        toolName: name
+      }
+    };
+  }
+  return {
+    ...baseOptions,
+    structuredOutputFormat: createOpenAIStructuredOutputFormat(options)
+  };
+}
+function createOpenAIStructuredOutputFormat(options) {
+  const name = getStructuredOutputName(options);
+  const format = zodTextFormat(
+    options.schema,
+    name,
+    options.schemaDescription ? { description: options.schemaDescription } : void 0
+  );
+  return {
+    type: "json_schema",
+    name,
+    ...options.schemaDescription ? { description: options.schemaDescription } : {},
+    strict: true,
+    schema: format.schema
+  };
+}
+function extractStructuredObject(result, schema, provider, structuredOutputName) {
+  const structuredToolCall = result.toolCalls.find(
+    (toolCall) => toolCall.name === structuredOutputName
+  );
+  if (structuredToolCall) {
+    return validateStructuredToolArguments(
+      schema,
+      structuredToolCall.arguments,
+      provider
+    );
+  }
+  const rawOutput = result.content?.trim();
+  if (rawOutput && rawOutput.length > 0) {
+    return parseAndValidateStructuredPayload(schema, rawOutput, provider);
+  }
+  throw new StructuredOutputNoObjectGeneratedError(
+    "model did not emit a structured object payload",
+    provider
+  );
+}
+async function* transformStructuredOutputStream(stream, schema, provider, structuredOutputName) {
+  let validatedObject;
+  let contentBuffer = "";
+  const toolArgumentDeltas = /* @__PURE__ */ new Map();
+  for await (const event of stream) {
+    if (event.type === "text-delta") {
+      contentBuffer += event.text;
+      yield {
+        type: "object-delta",
+        text: event.text
+      };
+      continue;
+    }
+    if (event.type === "tool-call-delta") {
+      const previous = toolArgumentDeltas.get(event.toolCallId) ?? "";
+      toolArgumentDeltas.set(
+        event.toolCallId,
+        `${previous}${event.argumentsDelta}`
+      );
+      yield {
+        type: "object-delta",
+        text: event.argumentsDelta
+      };
+      continue;
+    }
+    if (event.type === "tool-call-end" && event.toolCall.name === structuredOutputName) {
+      validatedObject = validateStructuredToolArguments(
+        schema,
+        event.toolCall.arguments,
+        provider
+      );
+      yield {
+        type: "object",
+        object: validatedObject
+      };
+      continue;
+    }
+    if (event.type === "finish") {
+      if (validatedObject === void 0) {
+        const fallbackPayload = getFallbackStructuredPayload(
+          contentBuffer,
+          toolArgumentDeltas
+        );
+        if (!fallbackPayload) {
+          throw new StructuredOutputNoObjectGeneratedError(
+            "structured output stream ended without an object payload",
+            provider
+          );
+        }
+        validatedObject = parseAndValidateStructuredPayload(
+          schema,
+          fallbackPayload,
+          provider
+        );
+        yield {
+          type: "object",
+          object: validatedObject
+        };
+      }
+      yield {
+        type: "finish",
+        finishReason: event.finishReason,
+        usage: event.usage
+      };
+    }
+  }
+}
+function getFallbackStructuredPayload(contentBuffer, toolArgumentDeltas) {
+  for (const delta of toolArgumentDeltas.values()) {
+    const trimmed = delta.trim();
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
+  }
+  const trimmedContent = contentBuffer.trim();
+  if (trimmedContent.length > 0) {
+    return trimmedContent;
+  }
+  return void 0;
+}
+function validateStructuredToolArguments(schema, toolArguments, provider) {
+  return validateStructuredObject(
+    schema,
+    toolArguments,
+    provider,
+    JSON.stringify(toolArguments)
+  );
+}
+function parseAndValidateStructuredPayload(schema, rawPayload, provider) {
+  const parsedPayload = parseJson(rawPayload, provider);
+  return validateStructuredObject(
+    schema,
+    parsedPayload,
+    provider,
+    rawPayload
+  );
+}
+function parseJson(rawOutput, provider) {
+  try {
+    return JSON.parse(rawOutput);
+  } catch (error) {
+    throw new StructuredOutputParseError(
+      "failed to parse structured output as JSON",
+      provider,
+      {
+        rawOutput,
+        cause: error
+      }
+    );
+  }
+}
+function validateStructuredObject(schema, value, provider, rawOutput) {
+  const parsed = schema.safeParse(value);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  throw new StructuredOutputValidationError(
+    "structured output does not match schema",
+    provider,
+    formatZodIssues(parsed.error.issues),
+    {
+      rawOutput
+    }
+  );
+}
+function formatZodIssues(issues) {
+  return issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.map((segment) => String(segment)).join(".") : "<root>";
+    return `${path}: ${issue.message}`;
+  });
+}
+
+// src/chat-completions/chat-model.ts
+function createOpenAIChatCompletionsModel(client, modelId, modelOptions = {}) {
+  const provider = modelOptions.providerId ?? "openai";
+  const structuredOutputMode = modelOptions.structuredOutputMode ?? (modelOptions.compatibility ? "tool" : "native");
+  const nonStandardReasoning = modelOptions.nonStandardReasoning ?? modelOptions.compatibility;
+  async function callOpenAIChatCompletionsApi(request, signal) {
+    try {
+      return await client.chat.completions.create(request, {
+        signal
+      });
+    } catch (error) {
+      throw wrapOpenAIError(error, provider);
+    }
+  }
+  async function generateChat(options) {
+    const request = createGenerateRequest(modelId, options, modelOptions);
+    const response = await callOpenAIChatCompletionsApi(request, options.signal);
+    return mapGenerateResponse(response, {
+      compatibility: nonStandardReasoning
+    });
+  }
+  async function streamChat(options) {
+    const request = createStreamRequest(modelId, options, modelOptions);
+    return createChatStream(
+      async () => transformStream(
+        await callOpenAIChatCompletionsApi(request, options.signal),
+        {
+          compatibility: nonStandardReasoning
+        }
+      ),
+      { signal: options.signal }
+    );
+  }
+  return {
+    provider,
+    modelId,
+    capabilities: getOpenAIModelCapabilities(modelId),
+    generate: generateChat,
+    stream: streamChat,
+    async generateObject(options) {
+      const structuredOptions = createStructuredOutputRequestOptions(
+        options,
+        structuredOutputMode
+      );
+      const result = await generateChat(structuredOptions);
+      const structuredOutputName = getStructuredOutputName(options);
+      const object = extractStructuredObject(
+        result,
+        options.schema,
+        provider,
+        structuredOutputName
+      );
+      return {
+        object,
+        finishReason: result.finishReason,
+        usage: result.usage
+      };
+    },
+    async streamObject(options) {
+      const structuredOptions = createStructuredOutputRequestOptions(
+        options,
+        structuredOutputMode
+      );
+      const stream = await streamChat(structuredOptions);
+      const structuredOutputName = getStructuredOutputName(options);
+      return createObjectStream(
+        transformStructuredOutputStream(
+          stream,
+          options.schema,
+          provider,
+          structuredOutputName
+        ),
+        {
+          signal: options.signal
+        }
+      );
+    }
+  };
+}
+
+// src/shared/provider-factory.ts
+import OpenAI from "openai";
+
+// src/chat-model.ts
+import { createObjectStream as createObjectStream2, createChatStream as createChatStream2 } from "@core-ai/core-ai";
+
+// src/chat-adapter.ts
+import { getProviderMetadata, clampReasoningEffort as clampReasoningEffort2 } from "@core-ai/core-ai";
+var ENCRYPTED_REASONING_INCLUDE = "reasoning.encrypted_content";
+var REASONING_SUMMARY_SEPARATOR = "\n\n";
+function convertMessages2(messages) {
+  return messages.flatMap(convertMessage2);
+}
+function convertMessage2(message) {
+  if (message.role === "system") {
+    return [
+      {
+        role: "developer",
+        content: message.content
+      }
+    ];
+  }
+  if (message.role === "user") {
+    return [
+      {
+        role: "user",
+        content: typeof message.content === "string" ? message.content : message.content.map(convertUserContentPart2)
+      }
+    ];
+  }
+  if (message.role === "assistant") {
+    return convertAssistantMessage(message.parts);
+  }
+  return [
+    {
+      type: "function_call_output",
+      call_id: message.toolCallId,
+      output: message.content
+    }
+  ];
+}
+function convertAssistantMessage(parts) {
+  const items = [];
+  const textParts = [];
+  const flushTextBuffer = () => {
+    if (textParts.length === 0) {
+      return;
+    }
+    items.push({
+      role: "assistant",
+      content: textParts.join("\n\n")
+    });
+    textParts.length = 0;
+  };
+  for (const part of parts) {
+    if (part.type === "text") {
+      textParts.push(part.text);
+      continue;
+    }
+    if (part.type === "reasoning") {
+      if (getProviderMetadata(
+        part.providerMetadata,
+        "openai"
+      ) == null) {
+        if (part.text.length > 0) {
+          textParts.push(`<thinking>${part.text}</thinking>`);
+        }
+        continue;
+      }
+      flushTextBuffer();
+      const encryptedContent = getEncryptedReasoningContent(part);
+      items.push({
+        type: "reasoning",
+        summary: [
+          {
+            type: "summary_text",
+            text: part.text
+          }
+        ],
+        ...encryptedContent ? { encrypted_content: encryptedContent } : {}
+      });
+      continue;
+    }
+    flushTextBuffer();
+    items.push({
+      type: "function_call",
+      call_id: part.toolCall.id,
+      name: part.toolCall.name,
+      arguments: JSON.stringify(part.toolCall.arguments)
+    });
+  }
+  flushTextBuffer();
+  return items;
+}
+function getEncryptedReasoningContent(part) {
+  const { encryptedContent } = getProviderMetadata(
+    part.providerMetadata,
+    "openai"
+  ) ?? {};
+  return typeof encryptedContent === "string" && encryptedContent.length > 0 ? encryptedContent : void 0;
+}
+function convertUserContentPart2(part) {
+  if (part.type === "text") {
+    return {
+      type: "input_text",
+      text: part.text
+    };
+  }
+  if (part.type === "image") {
+    const imageUrl = part.source.type === "url" ? part.source.url : `data:${part.source.mediaType};base64,${part.source.data}`;
+    return {
+      type: "input_image",
+      image_url: imageUrl
+    };
+  }
+  return {
+    type: "input_file",
+    file_data: part.data,
+    ...part.filename ? { filename: part.filename } : {}
+  };
+}
+function createGenerateRequest2(modelId, options) {
+  return createRequest2(
+    modelId,
+    options,
+    false
+  );
+}
+function createStreamRequest2(modelId, options) {
+  return createRequest2(
+    modelId,
+    options,
+    true
+  );
+}
+function createRequest2(modelId, options, stream) {
+  const openaiOptions = parseOpenAIResponsesGenerateProviderOptions(
+    options.providerOptions
+  );
+  const request = {
+    ...createRequestBase2(modelId, options),
+    ...stream ? { stream: true } : {},
+    ...options.structuredOutputFormat ? { text: { format: options.structuredOutputFormat } } : {},
+    ...mapOpenAIProviderOptionsToRequestFields2(openaiOptions)
+  };
+  if (options.reasoning && getOpenAIModelCapabilities(modelId).reasoning.supported) {
+    request.include = mergeInclude(request.include, [
+      ENCRYPTED_REASONING_INCLUDE
+    ]);
+  }
+  return request;
+}
+function createRequestBase2(modelId, options) {
+  validateOpenAIReasoningConfig(modelId, options);
+  return {
+    model: modelId,
+    store: false,
+    input: convertMessages2(options.messages),
+    ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertResponseTools(options.tools) } : {},
+    ...options.toolChoice ? { tool_choice: convertResponseToolChoice(options.toolChoice) } : {},
+    ...mapReasoningToRequestFields2(modelId, options),
+    ...mapSamplingToRequestFields2(options)
+  };
+}
+function convertResponseTools(tools) {
+  return convertTools(tools).map((tool) => ({
+    type: "function",
+    name: tool.function.name,
+    description: tool.function.description,
+    parameters: tool.function.parameters
+  }));
+}
+function convertResponseToolChoice(choice) {
+  const converted = convertToolChoice(choice);
+  if (typeof converted === "string") {
+    return converted;
+  }
+  return {
+    type: "function",
+    name: converted.function.name
+  };
+}
+function mergeInclude(value, requiredIncludes) {
+  const include = Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+  for (const requiredInclude of requiredIncludes) {
+    if (!include.includes(requiredInclude)) {
+      include.push(requiredInclude);
+    }
+  }
+  return include.length > 0 ? include : void 0;
+}
+function mapSamplingToRequestFields2(options) {
+  return {
+    ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+    ...options.maxTokens !== void 0 ? { max_output_tokens: options.maxTokens } : {},
+    ...options.topP !== void 0 ? { top_p: options.topP } : {}
+  };
+}
+function mapOpenAIProviderOptionsToRequestFields2(options) {
+  return {
+    ...options?.store !== void 0 ? { store: options.store } : {},
+    ...options?.serviceTier !== void 0 ? { service_tier: options.serviceTier } : {},
+    ...options?.include ? { include: options.include } : {},
+    ...options?.parallelToolCalls !== void 0 ? { parallel_tool_calls: options.parallelToolCalls } : {},
+    ...options?.user !== void 0 ? { user: options.user } : {}
+  };
+}
+function mapGenerateResponse2(response) {
+  const parts = [];
+  for (const item of response.output) {
+    if (isReasoningItem(item)) {
+      const reasoningPart = mapReasoningPart(item);
+      if (reasoningPart) {
+        parts.push(reasoningPart);
+      }
+      continue;
+    }
+    if (isOutputMessage(item)) {
+      parts.push(...mapMessageTextParts(item));
+      continue;
+    }
+    if (isFunctionToolCall(item)) {
+      parts.push({
+        type: "tool-call",
+        toolCall: {
+          id: item.call_id,
+          name: item.name,
+          arguments: safeParseJsonObject(item.arguments)
+        }
+      });
+    }
+  }
+  const content = getTextContent(parts);
+  const reasoning = getReasoningText(parts);
+  const toolCalls = getToolCalls(parts);
+  return {
+    parts,
+    content,
+    reasoning,
+    toolCalls,
+    finishReason: mapFinishReason2(response, toolCalls.length > 0),
+    usage: mapUsage(response.usage)
+  };
+}
+function mapReasoningPart(item) {
+  const text = getReasoningSummaryText(item.summary);
+  const encryptedContent = typeof item.encrypted_content === "string" && item.encrypted_content.length > 0 ? item.encrypted_content : void 0;
+  if (text.length === 0 && !encryptedContent) {
+    return null;
+  }
+  return {
+    type: "reasoning",
+    text,
+    providerMetadata: {
+      openai: { ...encryptedContent ? { encryptedContent } : {} }
+    }
+  };
+}
+function getReasoningSummaryText(summary) {
+  return summary.map((item) => item.text).join(REASONING_SUMMARY_SEPARATOR);
+}
+function mapMessageTextParts(message) {
+  return message.content.flatMap(
+    (contentItem) => contentItem.type === "output_text" && contentItem.text.length > 0 ? [{ type: "text", text: contentItem.text }] : []
+  );
+}
+function getTextContent(parts) {
+  return getJoinedPartText(parts, "text", "");
+}
+function getReasoningText(parts) {
+  return getJoinedPartText(parts, "reasoning", REASONING_SUMMARY_SEPARATOR);
+}
+function getJoinedPartText(parts, type, separator) {
+  const text = parts.flatMap(
+    (part) => part.type === type && "text" in part ? [part.text] : []
+  ).join(separator);
+  return text.length > 0 ? text : null;
+}
+function getToolCalls(parts) {
+  return parts.flatMap(
+    (part) => part.type === "tool-call" ? [part.toolCall] : []
+  );
+}
+function mapFinishReason2(response, hasToolCalls) {
+  const incompleteReason = response.incomplete_details?.reason;
+  if (incompleteReason === "max_output_tokens") {
+    return "length";
+  }
+  if (incompleteReason === "content_filter") {
+    return "content-filter";
+  }
+  if (hasToolCalls) {
+    return "tool-calls";
+  }
+  if (response.status === "completed") {
+    return "stop";
+  }
+  return "unknown";
+}
+function mapUsage(usage) {
+  const reasoningTokens = usage?.output_tokens_details?.reasoning_tokens;
+  return {
+    inputTokens: usage?.input_tokens ?? 0,
+    outputTokens: usage?.output_tokens ?? 0,
+    inputTokenDetails: {
+      cacheReadTokens: usage?.input_tokens_details?.cached_tokens ?? 0,
+      cacheWriteTokens: 0
+    },
+    outputTokenDetails: {
+      ...reasoningTokens !== void 0 ? { reasoningTokens } : {}
+    }
+  };
+}
+function getReasoningSummaryKey(part) {
+  return `${part.itemId}:${part.summaryIndex}`;
+}
+function isSameReasoningSummaryPart(left, right) {
+  return left.itemId === right.itemId && left.summaryIndex === right.summaryIndex;
+}
+function getReasoningStartTransition(reasoningStarted) {
+  if (reasoningStarted) {
+    return {
+      nextReasoningStarted: true,
+      event: null
+    };
+  }
+  return {
+    nextReasoningStarted: true,
+    event: { type: "reasoning-start" }
+  };
+}
+function getReasoningEndTransition(reasoningStarted, providerMetadata) {
+  if (!reasoningStarted) {
+    return {
+      nextReasoningStarted: false,
+      event: null
+    };
+  }
+  return {
+    nextReasoningStarted: false,
+    event: {
+      type: "reasoning-end",
+      providerMetadata
+    }
+  };
+}
+async function* transformStream2(stream) {
+  const bufferedToolCalls = /* @__PURE__ */ new Map();
+  const emittedToolCalls = /* @__PURE__ */ new Set();
+  const startedToolCalls = /* @__PURE__ */ new Set();
+  const seenSummaryDeltas = /* @__PURE__ */ new Set();
+  const emittedReasoningItems = /* @__PURE__ */ new Set();
+  let latestResponse;
+  let textOpen = false;
+  let reasoningStarted = false;
+  let latestReasoningSummaryPart;
+  const upsertBufferedToolCall = (outputIndex, getNextToolCall) => {
+    const nextToolCall = getNextToolCall(
+      bufferedToolCalls.get(outputIndex)
+    );
+    bufferedToolCalls.set(outputIndex, nextToolCall);
+    return nextToolCall;
+  };
+  const getNextReasoningStartEvent = () => {
+    const transition = getReasoningStartTransition(reasoningStarted);
+    reasoningStarted = transition.nextReasoningStarted;
+    return transition.event;
+  };
+  const startText = function* () {
+    if (textOpen) {
+      return;
+    }
+    textOpen = true;
+    yield { type: "text-start" };
+  };
+  const closeText = function* () {
+    if (!textOpen) {
+      return;
+    }
+    textOpen = false;
+    yield { type: "text-end" };
+  };
+  const getNextReasoningEndEvent = (providerMetadata) => {
+    const transition = getReasoningEndTransition(
+      reasoningStarted,
+      providerMetadata
+    );
+    reasoningStarted = transition.nextReasoningStarted;
+    if (transition.event) {
+      latestReasoningSummaryPart = void 0;
+    }
+    return transition.event;
+  };
+  const getReasoningSummarySeparatorEvent = (currentPart) => {
+    const previousPart = latestReasoningSummaryPart;
+    latestReasoningSummaryPart = currentPart;
+    if (previousPart === void 0 || isSameReasoningSummaryPart(previousPart, currentPart)) {
+      return null;
+    }
+    return {
+      type: "reasoning-delta",
+      text: REASONING_SUMMARY_SEPARATOR
+    };
+  };
+  for await (const event of stream) {
+    if (event.type === "response.reasoning_summary_text.delta") {
+      const summaryPart = {
+        itemId: event.item_id,
+        summaryIndex: event.summary_index
+      };
+      seenSummaryDeltas.add(getReasoningSummaryKey(summaryPart));
+      emittedReasoningItems.add(event.item_id);
+      const reasoningStartEvent = getNextReasoningStartEvent();
+      if (reasoningStartEvent) {
+        yield* closeText();
+        yield reasoningStartEvent;
+      }
+      const separatorEvent = getReasoningSummarySeparatorEvent(summaryPart);
+      if (separatorEvent) {
+        yield separatorEvent;
+      }
+      yield {
+        type: "reasoning-delta",
+        text: event.delta
+      };
+      continue;
+    }
+    if (event.type === "response.reasoning_summary_text.done") {
+      const summaryPart = {
+        itemId: event.item_id,
+        summaryIndex: event.summary_index
+      };
+      const key = getReasoningSummaryKey(summaryPart);
+      if (!seenSummaryDeltas.has(key) && event.text.length > 0) {
+        emittedReasoningItems.add(event.item_id);
+        const reasoningStartEvent = getNextReasoningStartEvent();
+        if (reasoningStartEvent) {
+          yield* closeText();
+          yield reasoningStartEvent;
+        }
+        const separatorEvent = getReasoningSummarySeparatorEvent(summaryPart);
+        if (separatorEvent) {
+          yield separatorEvent;
+        }
+        yield {
+          type: "reasoning-delta",
+          text: event.text
+        };
+      }
+      continue;
+    }
+    if (event.type === "response.output_text.delta") {
+      const reasoningEndEvent2 = getNextReasoningEndEvent({ openai: {} });
+      if (reasoningEndEvent2) {
+        yield reasoningEndEvent2;
+      }
+      yield* startText();
+      yield {
+        type: "text-delta",
+        text: event.delta
+      };
+      continue;
+    }
+    if (event.type === "response.output_item.added") {
+      if (!isFunctionToolCall(event.item)) {
+        continue;
+      }
+      yield* closeText();
+      const toolCallId = event.item.call_id;
+      const toolCallName = event.item.name;
+      const toolCallArguments = event.item.arguments;
+      upsertBufferedToolCall(event.output_index, () => ({
+        id: toolCallId,
+        name: toolCallName,
+        arguments: toolCallArguments
+      }));
+      const shouldStartToolCall = !startedToolCalls.has(toolCallId);
+      if (shouldStartToolCall) {
+        startedToolCalls.add(toolCallId);
+        yield {
+          type: "tool-call-start",
+          toolCallId,
+          toolName: toolCallName
+        };
+      }
+      continue;
+    }
+    if (event.type === "response.function_call_arguments.delta") {
+      yield* closeText();
+      const currentToolCall = upsertBufferedToolCall(
+        event.output_index,
+        (bufferedToolCall) => ({
+          id: bufferedToolCall?.id ?? event.item_id,
+          name: bufferedToolCall?.name ?? "",
+          arguments: `${bufferedToolCall?.arguments ?? ""}${event.delta}`
+        })
+      );
+      const shouldStartToolCall = !startedToolCalls.has(
+        currentToolCall.id
+      );
+      if (shouldStartToolCall) {
+        startedToolCalls.add(currentToolCall.id);
+        yield {
+          type: "tool-call-start",
+          toolCallId: currentToolCall.id,
+          toolName: currentToolCall.name
+        };
+      }
+      yield {
+        type: "tool-call-delta",
+        toolCallId: currentToolCall.id,
+        argumentsDelta: event.delta
+      };
+      continue;
+    }
+    if (event.type === "response.output_item.done") {
+      if (isReasoningItem(event.item)) {
+        if (!emittedReasoningItems.has(event.item.id)) {
+          const summaryText = getReasoningSummaryText(
+            event.item.summary
+          );
+          if (summaryText.length > 0) {
+            const reasoningStartEvent = getNextReasoningStartEvent();
+            if (reasoningStartEvent) {
+              yield* closeText();
+              yield reasoningStartEvent;
+            }
+            yield {
+              type: "reasoning-delta",
+              text: summaryText
+            };
+          }
+        }
+        const encryptedContent = typeof event.item.encrypted_content === "string" && event.item.encrypted_content.length > 0 ? event.item.encrypted_content : void 0;
+        if (encryptedContent) {
+          const reasoningStartEvent = getNextReasoningStartEvent();
+          if (reasoningStartEvent) {
+            yield* closeText();
+            yield reasoningStartEvent;
+          }
+        }
+        const reasoningEndEvent2 = getNextReasoningEndEvent({
+          openai: {
+            ...encryptedContent ? { encryptedContent } : {}
+          }
+        });
+        if (reasoningEndEvent2) {
+          yield reasoningEndEvent2;
+        }
+        continue;
+      }
+      if (!isFunctionToolCall(event.item)) {
+        continue;
+      }
+      yield* closeText();
+      const toolCallId = event.item.call_id;
+      const toolCallName = event.item.name;
+      const toolCallArguments = event.item.arguments;
+      const currentToolCall = upsertBufferedToolCall(
+        event.output_index,
+        (bufferedToolCall) => ({
+          id: toolCallId,
+          name: toolCallName,
+          arguments: toolCallArguments || bufferedToolCall?.arguments || ""
+        })
+      );
+      if (!emittedToolCalls.has(currentToolCall.id)) {
+        emittedToolCalls.add(currentToolCall.id);
+        yield {
+          type: "tool-call-end",
+          toolCall: {
+            id: currentToolCall.id,
+            name: currentToolCall.name,
+            arguments: safeParseJsonObject(
+              currentToolCall.arguments
+            )
+          }
+        };
+      }
+      continue;
+    }
+    if (event.type === "response.completed") {
+      latestResponse = event.response;
+      yield* closeText();
+      const reasoningEndEvent2 = getNextReasoningEndEvent({ openai: {} });
+      if (reasoningEndEvent2) {
+        yield reasoningEndEvent2;
+      }
+      for (const bufferedToolCall of bufferedToolCalls.values()) {
+        if (emittedToolCalls.has(bufferedToolCall.id)) {
+          continue;
+        }
+        emittedToolCalls.add(bufferedToolCall.id);
+        yield {
+          type: "tool-call-end",
+          toolCall: {
+            id: bufferedToolCall.id,
+            name: bufferedToolCall.name,
+            arguments: safeParseJsonObject(
+              bufferedToolCall.arguments
+            )
+          }
+        };
+      }
+      const hasToolCalls2 = bufferedToolCalls.size > 0;
+      yield {
+        type: "finish",
+        finishReason: mapFinishReason2(latestResponse, hasToolCalls2),
+        usage: mapUsage(latestResponse.usage)
+      };
+      return;
+    }
+  }
+  const reasoningEndEvent = getNextReasoningEndEvent({
+    openai: {}
+  });
+  yield* closeText();
+  if (reasoningEndEvent) {
+    yield reasoningEndEvent;
+  }
+  const hasToolCalls = bufferedToolCalls.size > 0;
+  const usage = latestResponse ? mapUsage(latestResponse.usage) : mapUsage(void 0);
+  const finishReason = latestResponse ? mapFinishReason2(latestResponse, hasToolCalls) : "unknown";
+  yield {
+    type: "finish",
+    finishReason,
+    usage
+  };
+}
+function mapReasoningToRequestFields2(modelId, options) {
+  if (!options.reasoning) {
+    return {};
+  }
+  const capabilities = getOpenAIModelCapabilities(modelId);
+  if (!capabilities.reasoning.supported) {
+    return {};
+  }
+  const effort = toOpenAIReasoningEffort(
+    clampReasoningEffort2(
+      options.reasoning.effort,
+      capabilities.reasoning.supportedEfforts
+    )
+  );
+  return {
+    reasoning: {
+      effort,
+      summary: "auto"
+    }
+  };
+}
+function isFunctionToolCall(item) {
+  return item.type === "function_call";
+}
+function isOutputMessage(item) {
+  return item.type === "message";
+}
+function isReasoningItem(item) {
+  return item.type === "reasoning";
+}
+
+// src/chat-model.ts
+function createOpenAIChatModel(client, modelId, providerId = "openai") {
+  const provider = providerId;
+  async function callOpenAIResponsesApi(request, signal) {
+    try {
+      return await client.responses.create(request, {
+        signal
+      });
+    } catch (error) {
+      throw wrapOpenAIError(error, provider);
+    }
+  }
+  async function generateChat(options) {
+    const request = createGenerateRequest2(modelId, options);
+    const response = await callOpenAIResponsesApi(
+      request,
+      options.signal
+    );
+    return mapGenerateResponse2(response);
+  }
+  async function streamChat(options) {
+    const request = createStreamRequest2(modelId, options);
+    return createChatStream2(
+      async () => transformStream2(
+        await callOpenAIResponsesApi(request, options.signal)
+      ),
+      { signal: options.signal }
+    );
+  }
+  return {
+    provider,
+    modelId,
+    capabilities: getOpenAIModelCapabilities(modelId),
+    generate: generateChat,
+    stream: streamChat,
+    async generateObject(options) {
+      const structuredOptions = createStructuredOutputRequestOptions(options);
+      const result = await generateChat(structuredOptions);
+      const structuredOutputName = getStructuredOutputName(options);
+      const object = extractStructuredObject(
+        result,
+        options.schema,
+        provider,
+        structuredOutputName
+      );
+      return {
+        object,
+        finishReason: result.finishReason,
+        usage: result.usage
+      };
+    },
+    async streamObject(options) {
+      const structuredOptions = createStructuredOutputRequestOptions(options);
+      const stream = await streamChat(structuredOptions);
+      const structuredOutputName = getStructuredOutputName(options);
+      return createObjectStream2(
+        transformStructuredOutputStream(
+          stream,
+          options.schema,
+          provider,
+          structuredOutputName
+        ),
+        {
+          signal: options.signal
+        }
+      );
+    }
+  };
+}
+
+// src/embedding-model.ts
+function createOpenAIEmbeddingModel(client, modelId) {
+  return {
+    provider: "openai",
+    modelId,
+    async embed(options) {
+      try {
+        const openaiOptions = parseOpenAIEmbedProviderOptions(
+          options.providerOptions
+        );
+        const response = await client.embeddings.create({
+          model: modelId,
+          input: options.input,
+          ...options.dimensions !== void 0 ? { dimensions: options.dimensions } : {},
+          ...mapOpenAIEmbedProviderOptionsToRequestFields(
+            openaiOptions
+          )
+        });
+        return {
+          embeddings: response.data.slice().sort((a, b) => a.index - b.index).map((item) => item.embedding),
+          usage: {
+            inputTokens: response.usage.prompt_tokens
+          }
+        };
+      } catch (error) {
+        throw wrapOpenAIError(error);
+      }
+    }
+  };
+}
+function mapOpenAIEmbedProviderOptionsToRequestFields(options) {
+  return {
+    ...options?.encodingFormat !== void 0 ? { encoding_format: options.encodingFormat } : {},
+    ...options?.user !== void 0 ? { user: options.user } : {}
+  };
+}
+
+// src/image-model.ts
+function createOpenAIImageModel(client, modelId) {
+  return {
+    provider: "openai",
+    modelId,
+    async generate(options) {
+      try {
+        const openaiOptions = parseOpenAIImageProviderOptions(
+          options.providerOptions
+        );
+        const request = {
+          model: modelId,
+          prompt: options.prompt,
+          ...options.n !== void 0 ? { n: options.n } : {},
+          ...options.size !== void 0 ? { size: options.size } : {},
+          ...mapOpenAIImageProviderOptionsToRequestFields(
+            openaiOptions
+          )
+        };
+        const response = await client.images.generate(
+          request
+        );
+        return {
+          images: (response.data ?? []).map((image) => ({
+            base64: image.b64_json ?? void 0,
+            url: image.url ?? void 0,
+            revisedPrompt: image.revised_prompt ?? void 0
+          }))
+        };
+      } catch (error) {
+        throw wrapOpenAIError(error);
+      }
+    }
+  };
+}
+function mapOpenAIImageProviderOptionsToRequestFields(options) {
+  return {
+    ...options?.background !== void 0 ? { background: options.background } : {},
+    ...options?.moderation !== void 0 ? { moderation: options.moderation } : {},
+    ...options?.outputCompression !== void 0 ? { output_compression: options.outputCompression } : {},
+    ...options?.outputFormat !== void 0 ? { output_format: options.outputFormat } : {},
+    ...options?.quality !== void 0 ? { quality: options.quality } : {},
+    ...options?.responseFormat !== void 0 ? { response_format: options.responseFormat } : {},
+    ...options?.style !== void 0 ? { style: options.style } : {},
+    ...options?.user !== void 0 ? { user: options.user } : {}
+  };
+}
+
+// src/shared/provider-factory.ts
+function createOpenAIProvider(options, factoryOptions = {}) {
+  const client = options.client ?? new OpenAI({
+    apiKey: options.apiKey,
+    baseURL: options.baseURL
+  });
+  const providerId = factoryOptions.providerId ?? "openai";
+  const compatibilityEnabled = factoryOptions.compatibility === true || typeof factoryOptions.compatibility === "object";
+  const compatibilityOptions = typeof factoryOptions.compatibility === "object" ? factoryOptions.compatibility : void 0;
+  const createResponsesModel = (modelId) => createOpenAIChatModel(client, modelId, providerId);
+  const createChatCompletionsModel = (modelId) => createOpenAIChatCompletionsModel(client, modelId, {
+    providerId,
+    compatibility: compatibilityEnabled,
+    nonStandardReasoning: compatibilityEnabled && (compatibilityOptions?.reasoning ?? true),
+    structuredOutputMode: compatibilityOptions?.structuredOutputMode,
+    maxTokensParameter: compatibilityOptions?.maxTokensParameter
+  });
+  const chat = {
+    chatModel: createChatCompletionsModel
+  };
+  return {
+    chatModel: factoryOptions.defaultApi === "chat-completions" ? createChatCompletionsModel : createResponsesModel,
+    chat,
+    embeddingModel: (modelId) => createOpenAIEmbeddingModel(client, modelId),
+    imageModel: (modelId) => createOpenAIImageModel(client, modelId)
+  };
+}
+
+export {
+  getOpenAIModelCapabilities,
+  openaiResponsesGenerateProviderOptionsSchema,
+  openaiChatGenerateProviderOptionsSchema,
+  openaiEmbedProviderOptionsSchema,
+  openaiImageProviderOptionsSchema,
+  openaiResponsesProviderOptionsSchema,
+  openaiCompatProviderOptionsSchema,
+  openaiCompatGenerateProviderOptionsSchema,
+  createOpenAIChatCompletionsModel,
+  createOpenAIProvider
+};