@core-ai/openai 0.4.0 → 0.6.0

package/README.md

@@ -12,6 +12,8 @@ npm install @core-ai/core-ai @core-ai/openai zod
 
 ## Usage
 
+The default entrypoint uses the OpenAI **Responses API**:
+
 ```ts
 import { generate } from '@core-ai/core-ai';
 import { createOpenAI } from '@core-ai/openai';
@@ -26,3 +28,22 @@ const result = await generate({
 
 console.log(result.content);
 ```
+
+## Chat Completions (Compat)
+
+For the legacy Chat Completions API — useful for Azure OpenAI, proxies, or third-party OpenAI-compatible endpoints — import from `@core-ai/openai/compat`:
+
+```ts
+import { generate } from '@core-ai/core-ai';
+import { createOpenAICompat } from '@core-ai/openai/compat';
+
+const openai = createOpenAICompat({ apiKey: process.env.OPENAI_API_KEY });
+const model = openai.chatModel('gpt-5-mini');
+
+const result = await generate({
+    model,
+    messages: [{ role: 'user', content: 'Hello!' }],
+});
+
+console.log(result.content);
+```

package/dist/chunk-7CU5JW63.js

@@ -0,0 +1,402 @@
+// 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 openaiCompatGenerateProviderOptionsSchema = 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 parseOpenAIResponsesGenerateProviderOptions(providerOptions) {
+  const rawOptions = providerOptions?.openai;
+  if (rawOptions === void 0) {
+    return void 0;
+  }
+  return openaiResponsesGenerateProviderOptionsSchema.parse(rawOptions);
+}
+function parseOpenAICompatGenerateProviderOptions(providerOptions) {
+  const rawOptions = providerOptions?.openai;
+  if (rawOptions === void 0) {
+    return void 0;
+  }
+  return openaiCompatGenerateProviderOptionsSchema.parse(rawOptions);
+}
+function parseOpenAIEmbedProviderOptions(providerOptions) {
+  const rawOptions = providerOptions?.openai;
+  if (rawOptions === void 0) {
+    return void 0;
+  }
+  return openaiEmbedProviderOptionsSchema.parse(rawOptions);
+}
+function parseOpenAIImageProviderOptions(providerOptions) {
+  const rawOptions = providerOptions?.openai;
+  if (rawOptions === void 0) {
+    return void 0;
+  }
+  return openaiImageProviderOptionsSchema.parse(rawOptions);
+}
+var openaiResponsesProviderOptionsSchema = openaiResponsesGenerateProviderOptionsSchema;
+var openaiCompatProviderOptionsSchema = openaiCompatGenerateProviderOptionsSchema;
+
+// src/openai-error.ts
+import { APIError } from "openai";
+import { ProviderError } from "@core-ai/core-ai";
+function wrapOpenAIError(error) {
+  if (error instanceof APIError) {
+    return new ProviderError(error.message, "openai", error.status, error);
+  }
+  return new ProviderError(
+    error instanceof Error ? error.message : String(error),
+    "openai",
+    void 0,
+    error
+  );
+}
+
+// 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/tools.ts
+import { zodToJsonSchema } from "zod-to-json-schema";
+var DEFAULT_STRUCTURED_OUTPUT_TOOL_NAME = "core_ai_generate_object";
+var DEFAULT_STRUCTURED_OUTPUT_TOOL_DESCRIPTION = "Return a JSON object that matches the requested schema.";
+function convertTools(tools) {
+  return Object.values(tools).map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: zodToJsonSchema(tool.parameters)
+    }
+  }));
+}
+function convertToolChoice(choice) {
+  if (typeof choice === "string") {
+    return choice;
+  }
+  return {
+    type: "function",
+    function: {
+      name: choice.toolName
+    }
+  };
+}
+function getStructuredOutputToolName(options) {
+  return options.schemaName?.trim() || DEFAULT_STRUCTURED_OUTPUT_TOOL_NAME;
+}
+function createStructuredOutputOptions(options) {
+  const toolName = getStructuredOutputToolName(options);
+  return {
+    messages: options.messages,
+    tools: {
+      structured_output: {
+        name: toolName,
+        description: options.schemaDescription ?? DEFAULT_STRUCTURED_OUTPUT_TOOL_DESCRIPTION,
+        parameters: options.schema
+      }
+    },
+    toolChoice: {
+      type: "tool",
+      toolName
+    },
+    reasoning: options.reasoning,
+    temperature: options.temperature,
+    maxTokens: options.maxTokens,
+    topP: options.topP,
+    providerOptions: options.providerOptions,
+    signal: options.signal
+  };
+}
+
+// src/model-capabilities.ts
+var DEFAULT_CAPABILITIES = {
+  reasoning: {
+    supportsEffort: true,
+    supportedRange: ["low", "medium", "high"],
+    restrictsSamplingParams: false
+  }
+};
+var MODEL_CAPABILITIES = {
+  "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.1": {
+    reasoning: {
+      supportsEffort: true,
+      supportedRange: ["low", "medium", "high"],
+      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
+    }
+  },
+  o3: {
+    reasoning: {
+      supportsEffort: true,
+      supportedRange: ["low", "medium", "high"],
+      restrictsSamplingParams: false
+    }
+  },
+  "o3-mini": {
+    reasoning: {
+      supportsEffort: true,
+      supportedRange: ["low", "medium", "high"],
+      restrictsSamplingParams: false
+    }
+  },
+  "o4-mini": {
+    reasoning: {
+      supportsEffort: true,
+      supportedRange: ["low", "medium", "high"],
+      restrictsSamplingParams: false
+    }
+  },
+  o1: {
+    reasoning: {
+      supportsEffort: true,
+      supportedRange: ["low", "medium", "high"],
+      restrictsSamplingParams: false
+    }
+  },
+  "o1-mini": {
+    reasoning: {
+      supportsEffort: false,
+      supportedRange: [],
+      restrictsSamplingParams: false
+    }
+  }
+};
+var EFFORT_RANK = {
+  minimal: 0,
+  low: 1,
+  medium: 2,
+  high: 3,
+  max: 4
+};
+function getOpenAIModelCapabilities(modelId) {
+  const normalizedModelId = normalizeModelId(modelId);
+  return MODEL_CAPABILITIES[normalizedModelId] ?? DEFAULT_CAPABILITIES;
+}
+function normalizeModelId(modelId) {
+  return modelId.replace(/-\d{8}$/, "");
+}
+function clampReasoningEffort(effort, supportedRange) {
+  if (supportedRange.length === 0 || supportedRange.includes(effort)) {
+    return effort;
+  }
+  const targetRank = EFFORT_RANK[effort];
+  let best = supportedRange[0] ?? effort;
+  let bestDistance = Math.abs(EFFORT_RANK[best] - targetRank);
+  for (const candidate of supportedRange) {
+    const distance = Math.abs(EFFORT_RANK[candidate] - targetRank);
+    if (distance < bestDistance) {
+      best = candidate;
+      bestDistance = distance;
+    }
+  }
+  return best;
+}
+function toOpenAIReasoningEffort(effort) {
+  if (effort === "max") {
+    return "xhigh";
+  }
+  return effort;
+}
+
+// src/shared/utils.ts
+import { ProviderError as ProviderError2 } 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;
+  }
+  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`,
+      "openai"
+    );
+  }
+}
+
+export {
+  getOpenAIModelCapabilities,
+  clampReasoningEffort,
+  toOpenAIReasoningEffort,
+  convertTools,
+  convertToolChoice,
+  getStructuredOutputToolName,
+  createStructuredOutputOptions,
+  safeParseJsonObject,
+  validateOpenAIReasoningConfig,
+  openaiResponsesGenerateProviderOptionsSchema,
+  openaiCompatGenerateProviderOptionsSchema,
+  openaiEmbedProviderOptionsSchema,
+  openaiImageProviderOptionsSchema,
+  parseOpenAIResponsesGenerateProviderOptions,
+  parseOpenAICompatGenerateProviderOptions,
+  openaiResponsesProviderOptionsSchema,
+  openaiCompatProviderOptionsSchema,
+  wrapOpenAIError,
+  createOpenAIEmbeddingModel,
+  createOpenAIImageModel
+};

package/dist/compat.d.ts

@@ -0,0 +1,18 @@
+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-DK-Tz0pz.js';
+import 'zod';
+
+type OpenAICompatProviderOptions = {
+    apiKey?: string;
+    baseURL?: string;
+    client?: OpenAI;
+};
+type OpenAICompatProvider = {
+    chatModel(modelId: string): ChatModel;
+    embeddingModel(modelId: string): EmbeddingModel;
+    imageModel(modelId: string): ImageModel;
+};
+declare function createOpenAICompat(options?: OpenAICompatProviderOptions): OpenAICompatProvider;
+
+export { type OpenAICompatProvider, type OpenAICompatProviderOptions, createOpenAICompat };