@core-ai/openai 0.3.0 → 0.5.1

package/dist/index.js

@@ -12,6 +12,140 @@ import {
 
 // src/chat-adapter.ts
 import { zodToJsonSchema } from "zod-to-json-schema";
+import { ProviderError } from "@core-ai/core-ai";
+
+// 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/chat-adapter.ts
 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 convertMessages(messages) {
@@ -31,11 +165,15 @@ function convertMessage(message) {
     };
   }
   if (message.role === "assistant") {
+    const text = message.parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+    const toolCalls = message.parts.flatMap(
+      (part) => part.type === "tool-call" ? [part.toolCall] : []
+    );
     return {
       role: "assistant",
-      content: message.content,
-      ...message.toolCalls && message.toolCalls.length > 0 ? {
-        tool_calls: message.toolCalls.map((toolCall) => ({
+      content: text.length > 0 ? text : null,
+      ...toolCalls.length > 0 ? {
+        tool_calls: toolCalls.map((toolCall) => ({
           id: toolCall.id,
           type: "function",
           function: {
@@ -119,6 +257,7 @@ function createStructuredOutputOptions(options) {
       type: "tool",
       toolName
     },
+    reasoning: options.reasoning,
     config: options.config,
     providerOptions: options.providerOptions,
     signal: options.signal
@@ -141,11 +280,14 @@ function createStreamRequest(modelId, options) {
   };
 }
 function createRequestBase(modelId, options) {
+  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,
     ...mapConfigToRequestFields(options.config)
   };
 }
@@ -163,27 +305,42 @@ function mapGenerateResponse(response) {
   const firstChoice = response.choices[0];
   if (!firstChoice) {
     return {
+      parts: [],
       content: null,
+      reasoning: null,
       toolCalls: [],
       finishReason: "unknown",
       usage: {
         inputTokens: 0,
         outputTokens: 0,
-        reasoningTokens: 0,
-        totalTokens: 0
+        inputTokenDetails: {
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0
+        },
+        outputTokenDetails: {}
       }
     };
   }
-  const reasoningTokens = response.usage?.completion_tokens_details?.reasoning_tokens ?? 0;
+  const reasoningTokens = response.usage?.completion_tokens_details?.reasoning_tokens;
+  const content = extractTextContent(firstChoice.message.content);
+  const toolCalls = parseToolCalls(firstChoice.message.tool_calls);
+  const parts = createAssistantParts(content, toolCalls);
   return {
-    content: firstChoice.message.content,
-    toolCalls: parseToolCalls(firstChoice.message.tool_calls),
+    parts,
+    content,
+    reasoning: null,
+    toolCalls,
     finishReason: mapFinishReason(firstChoice.finish_reason),
     usage: {
       inputTokens: response.usage?.prompt_tokens ?? 0,
       outputTokens: response.usage?.completion_tokens ?? 0,
-      reasoningTokens,
-      totalTokens: response.usage?.total_tokens ?? 0
+      inputTokenDetails: {
+        cacheReadTokens: response.usage?.prompt_tokens_details?.cached_tokens ?? 0,
+        cacheWriteTokens: 0
+      },
+      outputTokenDetails: {
+        ...reasoningTokens !== void 0 ? { reasoningTokens } : {}
+      }
     }
   };
 }
@@ -227,16 +384,25 @@ async function* transformStream(stream) {
   let usage = {
     inputTokens: 0,
     outputTokens: 0,
-    reasoningTokens: 0,
-    totalTokens: 0
+    inputTokenDetails: {
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0
+    },
+    outputTokenDetails: {}
   };
   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,
-        reasoningTokens: chunk.usage.completion_tokens_details?.reasoning_tokens ?? 0,
-        totalTokens: chunk.usage.total_tokens ?? 0
+        inputTokenDetails: {
+          cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens ?? 0,
+          cacheWriteTokens: 0
+        },
+        outputTokenDetails: {
+          ...reasoningTokens !== void 0 ? { reasoningTokens } : {}
+        }
       };
     }
     const choice = chunk.choices[0];
@@ -245,7 +411,7 @@ async function* transformStream(stream) {
     }
     if (choice.delta.content) {
       yield {
-        type: "content-delta",
+        type: "text-delta",
         text: choice.delta.content
       };
     }
@@ -320,15 +486,84 @@ function safeParseJsonObject(json) {
     return {};
   }
 }
+function validateOpenAIReasoningConfig(modelId, options) {
+  if (!options.reasoning) {
+    return;
+  }
+  const capabilities = getOpenAIModelCapabilities(modelId);
+  if (!capabilities.reasoning.restrictsSamplingParams) {
+    return;
+  }
+  if (options.config?.temperature !== void 0) {
+    throw new ProviderError(
+      `OpenAI model "${modelId}" does not support temperature when reasoning is enabled`,
+      "openai"
+    );
+  }
+  if (options.config?.topP !== void 0) {
+    throw new ProviderError(
+      `OpenAI model "${modelId}" does not support topP when reasoning is enabled`,
+      "openai"
+    );
+  }
+}
+function mapReasoningToRequestFields(modelId, options) {
+  if (!options.reasoning) {
+    return {};
+  }
+  const capabilities = getOpenAIModelCapabilities(modelId);
+  if (!capabilities.reasoning.supportsEffort) {
+    return {};
+  }
+  const clampedEffort = clampReasoningEffort(
+    options.reasoning.effort,
+    capabilities.reasoning.supportedRange
+  );
+  return {
+    reasoning_effort: toOpenAIReasoningEffort(clampedEffort)
+  };
+}
+function createAssistantParts(content, toolCalls) {
+  const parts = [];
+  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 } from "openai";
-import { ProviderError } from "@core-ai/core-ai";
+import { ProviderError as ProviderError2 } from "@core-ai/core-ai";
 function wrapOpenAIError(error) {
   if (error instanceof APIError) {
-    return new ProviderError(error.message, "openai", error.status, error);
+    return new ProviderError2(error.message, "openai", error.status, error);
   }
-  return new ProviderError(
+  return new ProviderError2(
     error instanceof Error ? error.message : String(error),
     "openai",
     void 0,
@@ -419,7 +654,7 @@ async function* transformStructuredOutputStream(stream, schema, provider, toolNa
   let contentBuffer = "";
   const toolArgumentDeltas = /* @__PURE__ */ new Map();
   for await (const event of stream) {
-    if (event.type === "content-delta") {
+    if (event.type === "text-delta") {
       contentBuffer += event.text;
       yield {
         type: "object-delta",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/openai",
-    "version": "0.3.0",
+    "version": "0.5.1",
     "description": "OpenAI provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -38,12 +38,11 @@
         "build": "tsup",
         "lint": "eslint src/ --max-warnings 0",
         "check-types": "tsc --noEmit",
-        "prepublishOnly": "npm run build",
         "test": "vitest run",
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.3.0",
+        "@core-ai/core-ai": "^0.5.1",
         "openai": "^6.1.0",
         "zod-to-json-schema": "^3.25.1"
     },