@core-ai/openai 0.7.0 → 0.8.0

package/dist/{chunk-T4N4CRQS.js → chunk-6CVAAVYM.js}

@@ -29,41 +29,53 @@ var openaiImageProviderOptionsSchema = z.object({
   style: z.enum(["vivid", "natural"]).optional(),
   user: z.string().optional()
 }).strict();
-function parseOpenAIResponsesGenerateProviderOptions(providerOptions) {
+function parseOpenAIProviderOptions(providerOptions, schema) {
   const rawOptions = providerOptions?.openai;
   if (rawOptions === void 0) {
     return void 0;
   }
-  return openaiResponsesGenerateProviderOptionsSchema.parse(rawOptions);
+  return schema.parse(rawOptions);
+}
+function parseOpenAIResponsesGenerateProviderOptions(providerOptions) {
+  return parseOpenAIProviderOptions(
+    providerOptions,
+    openaiResponsesGenerateProviderOptionsSchema
+  );
 }
 function parseOpenAICompatGenerateProviderOptions(providerOptions) {
-  const rawOptions = providerOptions?.openai;
-  if (rawOptions === void 0) {
-    return void 0;
-  }
-  return openaiCompatGenerateProviderOptionsSchema.parse(rawOptions);
+  return parseOpenAIProviderOptions(
+    providerOptions,
+    openaiCompatGenerateProviderOptionsSchema
+  );
 }
 function parseOpenAIEmbedProviderOptions(providerOptions) {
-  const rawOptions = providerOptions?.openai;
-  if (rawOptions === void 0) {
-    return void 0;
-  }
-  return openaiEmbedProviderOptionsSchema.parse(rawOptions);
+  return parseOpenAIProviderOptions(
+    providerOptions,
+    openaiEmbedProviderOptionsSchema
+  );
 }
 function parseOpenAIImageProviderOptions(providerOptions) {
-  const rawOptions = providerOptions?.openai;
-  if (rawOptions === void 0) {
-    return void 0;
-  }
-  return openaiImageProviderOptionsSchema.parse(rawOptions);
+  return parseOpenAIProviderOptions(
+    providerOptions,
+    openaiImageProviderOptionsSchema
+  );
 }
 var openaiResponsesProviderOptionsSchema = openaiResponsesGenerateProviderOptionsSchema;
 var openaiCompatProviderOptionsSchema = openaiCompatGenerateProviderOptionsSchema;
 
+// src/shared/provider-factory.ts
+import OpenAI from "openai";
+
 // src/openai-error.ts
-import { APIError } from "openai";
-import { ProviderError } from "@core-ai/core-ai";
+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) {
+  if (isOpenAIAbortError(error)) {
+    return new AbortedError(error, "openai");
+  }
   if (error instanceof APIError) {
     return new ProviderError(error.message, "openai", error.status, error);
   }
@@ -160,6 +172,19 @@ function mapOpenAIImageProviderOptionsToRequestFields(options) {
   };
 }
 
+// src/shared/provider-factory.ts
+function createOpenAIProvider(options, createChatModel) {
+  const client = options.client ?? new OpenAI({
+    apiKey: options.apiKey,
+    baseURL: options.baseURL
+  });
+  return {
+    chatModel: (modelId) => createChatModel(client, modelId),
+    embeddingModel: (modelId) => createOpenAIEmbeddingModel(client, modelId),
+    imageModel: (modelId) => createOpenAIImageModel(client, modelId)
+  };
+}
+
 // src/shared/tools.ts
 import { zodSchemaToJsonSchema } from "@core-ai/core-ai";
 var DEFAULT_STRUCTURED_OUTPUT_TOOL_NAME = "core_ai_generate_object";
@@ -212,7 +237,168 @@ function createStructuredOutputOptions(options) {
   };
 }
 
+// src/shared/structured-output.ts
+import {
+  StructuredOutputNoObjectGeneratedError,
+  StructuredOutputParseError,
+  StructuredOutputValidationError
+} from "@core-ai/core-ai";
+function extractStructuredObject(result, schema, provider, toolName) {
+  const structuredToolCall = result.toolCalls.find(
+    (toolCall) => toolCall.name === toolName
+  );
+  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, toolName) {
+  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 === toolName) {
+      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/model-capabilities.ts
+import {
+  stripModelDateSuffix
+} from "@core-ai/core-ai";
 var DEFAULT_CAPABILITIES = {
   reasoning: {
     supportsEffort: true,
@@ -220,42 +406,33 @@ var DEFAULT_CAPABILITIES = {
     restrictsSamplingParams: false
   }
 };
+var GPT_5_MAX_REASONING_CAPABILITIES = {
+  reasoning: {
+    supportsEffort: true,
+    supportedRange: ["low", "medium", "high", "max"],
+    restrictsSamplingParams: true
+  }
+};
+var GPT_5_MINIMAL_REASONING_CAPABILITIES = {
+  reasoning: {
+    supportsEffort: true,
+    supportedRange: ["minimal", "low", "medium", "high"],
+    restrictsSamplingParams: true
+  }
+};
+var NO_REASONING_EFFORT_CAPABILITIES = {
+  reasoning: {
+    supportsEffort: false,
+    supportedRange: [],
+    restrictsSamplingParams: false
+  }
+};
 var MODEL_CAPABILITIES = {
-  "gpt-5.4": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["low", "medium", "high", "max"],
-      restrictsSamplingParams: true
-    }
-  },
-  "gpt-5.4-pro": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["low", "medium", "high", "max"],
-      restrictsSamplingParams: true
-    }
-  },
-  "gpt-5.2": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["low", "medium", "high", "max"],
-      restrictsSamplingParams: true
-    }
-  },
-  "gpt-5.2-codex": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["low", "medium", "high", "max"],
-      restrictsSamplingParams: true
-    }
-  },
-  "gpt-5.2-pro": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["low", "medium", "high", "max"],
-      restrictsSamplingParams: true
-    }
-  },
+  "gpt-5.4": GPT_5_MAX_REASONING_CAPABILITIES,
+  "gpt-5.4-pro": 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": {
     reasoning: {
       supportsEffort: true,
@@ -263,27 +440,9 @@ var MODEL_CAPABILITIES = {
       restrictsSamplingParams: true
     }
   },
-  "gpt-5": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["minimal", "low", "medium", "high"],
-      restrictsSamplingParams: true
-    }
-  },
-  "gpt-5-mini": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["minimal", "low", "medium", "high"],
-      restrictsSamplingParams: true
-    }
-  },
-  "gpt-5-nano": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["minimal", "low", "medium", "high"],
-      restrictsSamplingParams: true
-    }
-  },
+  "gpt-5": GPT_5_MINIMAL_REASONING_CAPABILITIES,
+  "gpt-5-mini": GPT_5_MINIMAL_REASONING_CAPABILITIES,
+  "gpt-5-nano": GPT_5_MINIMAL_REASONING_CAPABILITIES,
   o3: {
     reasoning: {
       supportsEffort: true,
@@ -312,13 +471,7 @@ var MODEL_CAPABILITIES = {
       restrictsSamplingParams: false
     }
   },
-  "o1-mini": {
-    reasoning: {
-      supportsEffort: false,
-      supportedRange: [],
-      restrictsSamplingParams: false
-    }
-  }
+  "o1-mini": NO_REASONING_EFFORT_CAPABILITIES
 };
 var EFFORT_RANK = {
   minimal: 0,
@@ -327,12 +480,19 @@ var EFFORT_RANK = {
   high: 3,
   max: 4
 };
+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] ?? DEFAULT_CAPABILITIES;
 }
 function normalizeModelId(modelId) {
-  return modelId.replace(/-\d{8}$/, "");
+  return stripModelDateSuffix(modelId);
 }
 function clampReasoningEffort(effort, supportedRange) {
   if (supportedRange.length === 0 || supportedRange.includes(effort)) {
@@ -351,14 +511,11 @@ function clampReasoningEffort(effort, supportedRange) {
   return best;
 }
 function toOpenAIReasoningEffort(effort) {
-  if (effort === "max") {
-    return "xhigh";
-  }
-  return effort;
+  return OPENAI_REASONING_EFFORT_MAP[effort];
 }
 
 // src/shared/utils.ts
-import { ProviderError as ProviderError2 } from "@core-ai/core-ai";
+import { ValidationError } from "@core-ai/core-ai";
 function safeParseJsonObject(json) {
   try {
     const parsed = JSON.parse(json);
@@ -378,15 +535,17 @@ function validateOpenAIReasoningConfig(modelId, options) {
   if (!capabilities.reasoning.restrictsSamplingParams) {
     return;
   }
-  if (options.temperature !== void 0) {
-    throw new ProviderError2(
-      `OpenAI model "${modelId}" does not support temperature when reasoning is enabled`,
-      "openai"
-    );
-  }
-  if (options.topP !== void 0) {
-    throw new ProviderError2(
-      `OpenAI model "${modelId}" does not support topP when reasoning is enabled`,
+  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"
     );
   }
@@ -411,6 +570,7 @@ export {
   openaiResponsesProviderOptionsSchema,
   openaiCompatProviderOptionsSchema,
   wrapOpenAIError,
-  createOpenAIEmbeddingModel,
-  createOpenAIImageModel
+  extractStructuredObject,
+  transformStructuredOutputStream,
+  createOpenAIProvider
 };

package/dist/compat.d.ts

@@ -1,18 +1,11 @@
-import OpenAI from 'openai';
-import { ChatModel, EmbeddingModel, ImageModel } from '@core-ai/core-ai';
-export { O as OpenAICompatGenerateProviderOptions, a as OpenAICompatRequestOptions, o as openaiCompatGenerateProviderOptionsSchema, b as openaiCompatProviderOptionsSchema } from './provider-options-l7CmAA94.js';
+import { O as OpenAIProvider, a as OpenAIProviderBaseOptions } from './provider-options-DzqvHoId.js';
+export { b as OpenAICompatGenerateProviderOptions, c as OpenAICompatRequestOptions, o as openaiCompatGenerateProviderOptionsSchema, d as openaiCompatProviderOptionsSchema } from './provider-options-DzqvHoId.js';
+import 'openai';
+import '@core-ai/core-ai';
 import 'zod';
 
-type OpenAICompatProviderOptions = {
-    apiKey?: string;
-    baseURL?: string;
-    client?: OpenAI;
-};
-type OpenAICompatProvider = {
-    chatModel(modelId: string): ChatModel;
-    embeddingModel(modelId: string): EmbeddingModel;
-    imageModel(modelId: string): ImageModel;
-};
+type OpenAICompatProviderOptions = OpenAIProviderBaseOptions;
+type OpenAICompatProvider = OpenAIProvider;
 declare function createOpenAICompat(options?: OpenAICompatProviderOptions): OpenAICompatProvider;
 
 export { type OpenAICompatProvider, type OpenAICompatProviderOptions, createOpenAICompat };

package/dist/compat.js

@@ -2,9 +2,9 @@ import {
   clampReasoningEffort,
   convertToolChoice,
   convertTools,
-  createOpenAIEmbeddingModel,
-  createOpenAIImageModel,
+  createOpenAIProvider,
   createStructuredOutputOptions,
+  extractStructuredObject,
   getOpenAIModelCapabilities,
   getStructuredOutputToolName,
   openaiCompatGenerateProviderOptionsSchema,
@@ -12,21 +12,13 @@ import {
   parseOpenAICompatGenerateProviderOptions,
   safeParseJsonObject,
   toOpenAIReasoningEffort,
+  transformStructuredOutputStream,
   validateOpenAIReasoningConfig,
   wrapOpenAIError
-} from "./chunk-T4N4CRQS.js";
-
-// src/compat/provider.ts
-import OpenAI from "openai";
+} from "./chunk-6CVAAVYM.js";
 
 // src/compat/chat-model.ts
-import {
-  StructuredOutputNoObjectGeneratedError,
-  StructuredOutputParseError,
-  StructuredOutputValidationError,
-  createObjectStream,
-  createChatStream
-} from "@core-ai/core-ai";
+import { createObjectStream, createChatStream } from "@core-ai/core-ai";
 
 // src/compat/chat-adapter.ts
 function convertMessages(messages) {
@@ -441,169 +433,10 @@ function createOpenAICompatChatModel(client, modelId) {
     }
   };
 }
-function extractStructuredObject(result, schema, provider, toolName) {
-  const structuredToolCall = result.toolCalls.find(
-    (toolCall) => toolCall.name === toolName
-  );
-  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, toolName) {
-  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 === toolName) {
-      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/compat/provider.ts
 function createOpenAICompat(options = {}) {
-  const client = options.client ?? new OpenAI({
-    apiKey: options.apiKey,
-    baseURL: options.baseURL
-  });
-  return {
-    chatModel: (modelId) => createOpenAICompatChatModel(client, modelId),
-    embeddingModel: (modelId) => createOpenAIEmbeddingModel(client, modelId),
-    imageModel: (modelId) => createOpenAIImageModel(client, modelId)
-  };
+  return createOpenAIProvider(options, createOpenAICompatChatModel);
 }
 export {
   createOpenAICompat,

package/dist/index.d.ts

@@ -1,18 +1,11 @@
-import OpenAI from 'openai';
-import { ChatModel, EmbeddingModel, ImageModel } from '@core-ai/core-ai';
-export { O as OpenAICompatGenerateProviderOptions, a as OpenAICompatRequestOptions, c as OpenAIEmbedProviderOptions, d as OpenAIImageProviderOptions, e as OpenAIResponsesGenerateProviderOptions, f as OpenAIResponsesProviderOptions, o as openaiCompatGenerateProviderOptionsSchema, b as openaiCompatProviderOptionsSchema, g as openaiEmbedProviderOptionsSchema, h as openaiImageProviderOptionsSchema, i as openaiResponsesGenerateProviderOptionsSchema, j as openaiResponsesProviderOptionsSchema } from './provider-options-l7CmAA94.js';
+import { O as OpenAIProvider$1, a as OpenAIProviderBaseOptions } from './provider-options-DzqvHoId.js';
+export { b as OpenAICompatGenerateProviderOptions, c as OpenAICompatRequestOptions, e as OpenAIEmbedProviderOptions, f as OpenAIImageProviderOptions, g as OpenAIResponsesGenerateProviderOptions, h as OpenAIResponsesProviderOptions, o as openaiCompatGenerateProviderOptionsSchema, d as openaiCompatProviderOptionsSchema, i as openaiEmbedProviderOptionsSchema, j as openaiImageProviderOptionsSchema, k as openaiResponsesGenerateProviderOptionsSchema, l as openaiResponsesProviderOptionsSchema } from './provider-options-DzqvHoId.js';
+import 'openai';
+import '@core-ai/core-ai';
 import 'zod';
 
-type OpenAIProviderOptions = {
-    apiKey?: string;
-    baseURL?: string;
-    client?: OpenAI;
-};
-type OpenAIProvider = {
-    chatModel(modelId: string): ChatModel;
-    embeddingModel(modelId: string): EmbeddingModel;
-    imageModel(modelId: string): ImageModel;
-};
+type OpenAIProviderOptions = OpenAIProviderBaseOptions;
+type OpenAIProvider = OpenAIProvider$1;
 declare function createOpenAI(options?: OpenAIProviderOptions): OpenAIProvider;
 
 type OpenAIReasoningMetadata = {

package/dist/index.js

@@ -2,9 +2,9 @@ import {
   clampReasoningEffort,
   convertToolChoice,
   convertTools,
-  createOpenAIEmbeddingModel,
-  createOpenAIImageModel,
+  createOpenAIProvider,
   createStructuredOutputOptions,
+  extractStructuredObject,
   getOpenAIModelCapabilities,
   getStructuredOutputToolName,
   openaiCompatGenerateProviderOptionsSchema,
@@ -16,21 +16,13 @@ import {
   parseOpenAIResponsesGenerateProviderOptions,
   safeParseJsonObject,
   toOpenAIReasoningEffort,
+  transformStructuredOutputStream,
   validateOpenAIReasoningConfig,
   wrapOpenAIError
-} from "./chunk-T4N4CRQS.js";
-
-// src/provider.ts
-import OpenAI from "openai";
+} from "./chunk-6CVAAVYM.js";
 
 // src/chat-model.ts
-import {
-  StructuredOutputNoObjectGeneratedError,
-  StructuredOutputParseError,
-  StructuredOutputValidationError,
-  createObjectStream,
-  createChatStream
-} from "@core-ai/core-ai";
+import { createObjectStream, createChatStream } from "@core-ai/core-ai";
 
 // src/chat-adapter.ts
 import { getProviderMetadata } from "@core-ai/core-ai";
@@ -377,14 +369,26 @@ async function* transformStream(stream) {
     bufferedToolCalls.set(outputIndex, nextToolCall);
     return nextToolCall;
   };
+  const getNextReasoningStartEvent = () => {
+    const transition = getReasoningStartTransition(reasoningStarted);
+    reasoningStarted = transition.nextReasoningStarted;
+    return transition.event;
+  };
+  const getNextReasoningEndEvent = (providerMetadata) => {
+    const transition = getReasoningEndTransition(
+      reasoningStarted,
+      providerMetadata
+    );
+    reasoningStarted = transition.nextReasoningStarted;
+    return transition.event;
+  };
   for await (const event of stream) {
     if (event.type === "response.reasoning_summary_text.delta") {
       seenSummaryDeltas.add(`${event.item_id}:${event.summary_index}`);
       emittedReasoningItems.add(event.item_id);
-      const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
-      reasoningStarted = reasoningStartTransition.nextReasoningStarted;
-      if (reasoningStartTransition.event) {
-        yield reasoningStartTransition.event;
+      const reasoningStartEvent = getNextReasoningStartEvent();
+      if (reasoningStartEvent) {
+        yield reasoningStartEvent;
       }
       yield {
         type: "reasoning-delta",
@@ -396,10 +400,9 @@ async function* transformStream(stream) {
       const key = `${event.item_id}:${event.summary_index}`;
       if (!seenSummaryDeltas.has(key) && event.text.length > 0) {
         emittedReasoningItems.add(event.item_id);
-        const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
-        reasoningStarted = reasoningStartTransition.nextReasoningStarted;
-        if (reasoningStartTransition.event) {
-          yield reasoningStartTransition.event;
+        const reasoningStartEvent = getNextReasoningStartEvent();
+        if (reasoningStartEvent) {
+          yield reasoningStartEvent;
         }
         yield {
           type: "reasoning-delta",
@@ -473,10 +476,9 @@ async function* transformStream(stream) {
             event.item.summary
           );
           if (summaryText.length > 0) {
-            const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
-            reasoningStarted = reasoningStartTransition.nextReasoningStarted;
-            if (reasoningStartTransition.event) {
-              yield reasoningStartTransition.event;
+            const reasoningStartEvent = getNextReasoningStartEvent();
+            if (reasoningStartEvent) {
+              yield reasoningStartEvent;
             }
             yield {
               type: "reasoning-delta",
@@ -486,23 +488,20 @@ async function* transformStream(stream) {
         }
         const encryptedContent = typeof event.item.encrypted_content === "string" && event.item.encrypted_content.length > 0 ? event.item.encrypted_content : void 0;
         if (encryptedContent) {
-          const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
-          reasoningStarted = reasoningStartTransition.nextReasoningStarted;
-          if (reasoningStartTransition.event) {
-            yield reasoningStartTransition.event;
+          const reasoningStartEvent = getNextReasoningStartEvent();
+          if (reasoningStartEvent) {
+            yield reasoningStartEvent;
           }
         }
-        const reasoningEndTransition2 = getReasoningEndTransition(
-          reasoningStarted,
+        const reasoningEndEvent2 = getNextReasoningEndEvent(
           {
             openai: {
               ...encryptedContent ? { encryptedContent } : {}
             }
           }
         );
-        reasoningStarted = reasoningEndTransition2.nextReasoningStarted;
-        if (reasoningEndTransition2.event) {
-          yield reasoningEndTransition2.event;
+        if (reasoningEndEvent2) {
+          yield reasoningEndEvent2;
         }
         continue;
       }
@@ -537,13 +536,9 @@ async function* transformStream(stream) {
     }
     if (event.type === "response.completed") {
       latestResponse = event.response;
-      const reasoningEndTransition2 = getReasoningEndTransition(
-        reasoningStarted,
-        { openai: {} }
-      );
-      reasoningStarted = reasoningEndTransition2.nextReasoningStarted;
-      if (reasoningEndTransition2.event) {
-        yield reasoningEndTransition2.event;
+      const reasoningEndEvent2 = getNextReasoningEndEvent({ openai: {} });
+      if (reasoningEndEvent2) {
+        yield reasoningEndEvent2;
       }
       for (const bufferedToolCall of bufferedToolCalls.values()) {
         if (emittedToolCalls.has(bufferedToolCall.id)) {
@@ -570,12 +565,11 @@ async function* transformStream(stream) {
       return;
     }
   }
-  const reasoningEndTransition = getReasoningEndTransition(reasoningStarted, {
+  const reasoningEndEvent = getNextReasoningEndEvent({
     openai: {}
   });
-  reasoningStarted = reasoningEndTransition.nextReasoningStarted;
-  if (reasoningEndTransition.event) {
-    yield reasoningEndTransition.event;
+  if (reasoningEndEvent) {
+    yield reasoningEndEvent;
   }
   const hasToolCalls = bufferedToolCalls.size > 0;
   const usage = latestResponse ? mapUsage(latestResponse.usage) : mapUsage(void 0);
@@ -682,169 +676,10 @@ function createOpenAIChatModel(client, modelId) {
     }
   };
 }
-function extractStructuredObject(result, schema, provider, toolName) {
-  const structuredToolCall = result.toolCalls.find(
-    (toolCall) => toolCall.name === toolName
-  );
-  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, toolName) {
-  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 === toolName) {
-      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/provider.ts
 function createOpenAI(options = {}) {
-  const client = options.client ?? new OpenAI({
-    apiKey: options.apiKey,
-    baseURL: options.baseURL
-  });
-  return {
-    chatModel: (modelId) => createOpenAIChatModel(client, modelId),
-    embeddingModel: (modelId) => createOpenAIEmbeddingModel(client, modelId),
-    imageModel: (modelId) => createOpenAIImageModel(client, modelId)
-  };
+  return createOpenAIProvider(options, createOpenAIChatModel);
 }
 export {
   createOpenAI,

package/dist/{provider-options-l7CmAA94.d.ts → provider-options-DzqvHoId.d.ts}

@@ -1,5 +1,18 @@
+import OpenAI from 'openai';
+import { ChatModel, EmbeddingModel, ImageModel } from '@core-ai/core-ai';
 import { z } from 'zod';
 
+type OpenAIProviderBaseOptions = {
+    apiKey?: string;
+    baseURL?: string;
+    client?: OpenAI;
+};
+type OpenAIProvider = {
+    chatModel(modelId: string): ChatModel;
+    embeddingModel(modelId: string): EmbeddingModel;
+    imageModel(modelId: string): ImageModel;
+};
+
 declare const openaiResponsesGenerateProviderOptionsSchema: z.ZodObject<{
     store: z.ZodOptional<z.ZodBoolean>;
     serviceTier: z.ZodOptional<z.ZodEnum<{
@@ -117,4 +130,4 @@ declare const openaiCompatProviderOptionsSchema: z.ZodObject<{
 }, z.core.$strict>;
 type OpenAICompatRequestOptions = OpenAICompatGenerateProviderOptions;
 
-export { type OpenAICompatGenerateProviderOptions as O, type OpenAICompatRequestOptions as a, openaiCompatProviderOptionsSchema as b, type OpenAIEmbedProviderOptions as c, type OpenAIImageProviderOptions as d, type OpenAIResponsesGenerateProviderOptions as e, type OpenAIResponsesProviderOptions as f, openaiEmbedProviderOptionsSchema as g, openaiImageProviderOptionsSchema as h, openaiResponsesGenerateProviderOptionsSchema as i, openaiResponsesProviderOptionsSchema as j, openaiCompatGenerateProviderOptionsSchema as o };
+export { type OpenAIProvider as O, type OpenAIProviderBaseOptions as a, type OpenAICompatGenerateProviderOptions as b, type OpenAICompatRequestOptions as c, openaiCompatProviderOptionsSchema as d, type OpenAIEmbedProviderOptions as e, type OpenAIImageProviderOptions as f, type OpenAIResponsesGenerateProviderOptions as g, type OpenAIResponsesProviderOptions as h, openaiEmbedProviderOptionsSchema as i, openaiImageProviderOptionsSchema as j, openaiResponsesGenerateProviderOptionsSchema as k, openaiResponsesProviderOptionsSchema as l, openaiCompatGenerateProviderOptionsSchema as o };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/openai",
-    "version": "0.7.0",
+    "version": "0.8.0",
     "description": "OpenAI provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -46,7 +46,7 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.7.0",
+        "@core-ai/core-ai": "^0.8.0",
         "openai": "^6.1.0"
     },
     "peerDependencies": {