@core-ai/openai 0.2.1 → 0.3.0

package/dist/index.js

@@ -2,12 +2,18 @@
 import OpenAI from "openai";
 
 // src/chat-model.ts
-import { createStreamResult } from "@core-ai/core-ai";
+import {
+  StructuredOutputNoObjectGeneratedError,
+  StructuredOutputParseError,
+  StructuredOutputValidationError,
+  createObjectStreamResult,
+  createStreamResult
+} from "@core-ai/core-ai";
 
 // src/chat-adapter.ts
-import { APIError } from "openai";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { ProviderError } from "@core-ai/core-ai";
+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) {
   return messages.map(convertMessage);
 }
@@ -91,38 +97,66 @@ function convertToolChoice(choice) {
     }
   };
 }
+function getStructuredOutputToolName(options) {
+  const trimmedName = options.schemaName?.trim();
+  if (trimmedName && trimmedName.length > 0) {
+    return trimmedName;
+  }
+  return 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
+    },
+    config: options.config,
+    providerOptions: options.providerOptions,
+    signal: options.signal
+  };
+}
 function createGenerateRequest(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) } : {},
-    ...options.config?.temperature !== void 0 ? { temperature: options.config.temperature } : {},
-    ...options.config?.maxTokens !== void 0 ? { max_tokens: options.config.maxTokens } : {},
-    ...options.config?.topP !== void 0 ? { top_p: options.config.topP } : {},
-    ...options.config?.stopSequences ? { stop: options.config.stopSequences } : {},
-    ...options.config?.frequencyPenalty !== void 0 ? { frequency_penalty: options.config.frequencyPenalty } : {},
-    ...options.config?.presencePenalty !== void 0 ? { presence_penalty: options.config.presencePenalty } : {},
+    ...createRequestBase(modelId, options),
     ...options.providerOptions
   };
 }
 function createStreamRequest(modelId, options) {
   return {
-    model: modelId,
-    messages: convertMessages(options.messages),
+    ...createRequestBase(modelId, options),
     stream: true,
     stream_options: {
       include_usage: true
     },
+    ...options.providerOptions
+  };
+}
+function createRequestBase(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) } : {},
-    ...options.config?.temperature !== void 0 ? { temperature: options.config.temperature } : {},
-    ...options.config?.maxTokens !== void 0 ? { max_tokens: options.config.maxTokens } : {},
-    ...options.config?.topP !== void 0 ? { top_p: options.config.topP } : {},
-    ...options.config?.stopSequences ? { stop: options.config.stopSequences } : {},
-    ...options.config?.frequencyPenalty !== void 0 ? { frequency_penalty: options.config.frequencyPenalty } : {},
-    ...options.config?.presencePenalty !== void 0 ? { presence_penalty: options.config.presencePenalty } : {},
-    ...options.providerOptions
+    ...mapConfigToRequestFields(options.config)
+  };
+}
+function mapConfigToRequestFields(config) {
+  return {
+    ...config?.temperature !== void 0 ? { temperature: config.temperature } : {},
+    ...config?.maxTokens !== void 0 ? { max_tokens: config.maxTokens } : {},
+    ...config?.topP !== void 0 ? { top_p: config.topP } : {},
+    ...config?.stopSequences ? { stop: config.stopSequences } : {},
+    ...config?.frequencyPenalty !== void 0 ? { frequency_penalty: config.frequencyPenalty } : {},
+    ...config?.presencePenalty !== void 0 ? { presence_penalty: config.presencePenalty } : {}
   };
 }
 function mapGenerateResponse(response) {
@@ -217,7 +251,9 @@ async function* transformStream(stream) {
     }
     if (choice.delta.tool_calls) {
       for (const partialToolCall of choice.delta.tool_calls) {
-        const current = bufferedToolCalls.get(partialToolCall.index) ?? {
+        const current = bufferedToolCalls.get(
+          partialToolCall.index
+        ) ?? {
           id: partialToolCall.id ?? `tool-${partialToolCall.index}`,
           name: partialToolCall.function?.name ?? "",
           arguments: ""
@@ -284,7 +320,11 @@ function safeParseJsonObject(json) {
     return {};
   }
 }
-function wrapError(error) {
+
+// 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);
   }
@@ -298,33 +338,210 @@ function wrapError(error) {
 
 // src/chat-model.ts
 function createOpenAIChatModel(client, modelId) {
+  const provider = "openai";
+  async function callOpenAIChatCompletionsApi(request) {
+    try {
+      return await client.chat.completions.create(
+        request
+      );
+    } catch (error) {
+      throw wrapOpenAIError(error);
+    }
+  }
+  async function generateChat(options) {
+    const request = createGenerateRequest(modelId, options);
+    const response = await callOpenAIChatCompletionsApi(request);
+    return mapGenerateResponse(response);
+  }
+  async function streamChat(options) {
+    const request = createStreamRequest(modelId, options);
+    const stream = await callOpenAIChatCompletionsApi(request);
+    return createStreamResult(transformStream(stream));
+  }
   return {
-    provider: "openai",
+    provider,
     modelId,
-    async generate(options) {
-      try {
-        const request = createGenerateRequest(modelId, options);
-        const response = await client.chat.completions.create(request);
-        return mapGenerateResponse(response);
-      } catch (error) {
-        throw wrapError(error);
-      }
+    generate: generateChat,
+    stream: streamChat,
+    async generateObject(options) {
+      const structuredOptions = createStructuredOutputOptions(options);
+      const result = await generateChat(structuredOptions);
+      const toolName = getStructuredOutputToolName(options);
+      const object = extractStructuredObject(
+        result,
+        options.schema,
+        provider,
+        toolName
+      );
+      return {
+        object,
+        finishReason: result.finishReason,
+        usage: result.usage
+      };
     },
-    async stream(options) {
-      try {
-        const request = createStreamRequest(modelId, options);
-        const stream = await client.chat.completions.create(request);
-        return createStreamResult(transformStream(stream));
-      } catch (error) {
-        throw wrapError(error);
-      }
+    async streamObject(options) {
+      const structuredOptions = createStructuredOutputOptions(options);
+      const stream = await streamChat(structuredOptions);
+      const toolName = getStructuredOutputToolName(options);
+      return createObjectStreamResult(
+        transformStructuredOutputStream(
+          stream,
+          options.schema,
+          provider,
+          toolName
+        )
+      );
     }
   };
 }
+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 === "content-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/embedding-model.ts
-import { APIError as APIError2 } from "openai";
-import { ProviderError as ProviderError2 } from "@core-ai/core-ai";
 function createOpenAIEmbeddingModel(client, modelId) {
   return {
     provider: "openai",
@@ -344,26 +561,13 @@ function createOpenAIEmbeddingModel(client, modelId) {
           }
         };
       } catch (error) {
-        throw wrapError2(error);
+        throw wrapOpenAIError(error);
       }
     }
   };
 }
-function wrapError2(error) {
-  if (error instanceof APIError2) {
-    return new ProviderError2(error.message, "openai", error.status, error);
-  }
-  return new ProviderError2(
-    error instanceof Error ? error.message : String(error),
-    "openai",
-    void 0,
-    error
-  );
-}
 
 // src/image-model.ts
-import { APIError as APIError3 } from "openai";
-import { ProviderError as ProviderError3 } from "@core-ai/core-ai";
 function createOpenAIImageModel(client, modelId) {
   return {
     provider: "openai",
@@ -388,22 +592,11 @@ function createOpenAIImageModel(client, modelId) {
           }))
         };
       } catch (error) {
-        throw wrapError3(error);
+        throw wrapOpenAIError(error);
       }
     }
   };
 }
-function wrapError3(error) {
-  if (error instanceof APIError3) {
-    return new ProviderError3(error.message, "openai", error.status, error);
-  }
-  return new ProviderError3(
-    error instanceof Error ? error.message : String(error),
-    "openai",
-    void 0,
-    error
-  );
-}
 
 // src/provider.ts
 function createOpenAI(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/openai",
-    "version": "0.2.1",
+    "version": "0.3.0",
     "description": "OpenAI provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -43,7 +43,7 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.2.1",
+        "@core-ai/core-ai": "^0.3.0",
         "openai": "^6.1.0",
         "zod-to-json-schema": "^3.25.1"
     },