@core-ai/openai 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Omnifact (https://omnifact.ai)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+# @core-ai/openai
+
+OpenAI provider package for `@core-ai/core-ai`.
+
+## Installation
+
+```bash
+npm install @core-ai/core-ai @core-ai/openai zod
+```
+
+## Usage
+
+```ts
+import { generate } from '@core-ai/core-ai';
+import { createOpenAI } from '@core-ai/openai';
+
+const openai = createOpenAI({ 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/index.d.ts

@@ -0,0 +1,16 @@
+import OpenAI from 'openai';
+import { ChatModel, EmbeddingModel, ImageModel } from '@core-ai/core-ai';
+
+type OpenAIProviderOptions = {
+    apiKey?: string;
+    baseURL?: string;
+    client?: OpenAI;
+};
+type OpenAIProvider = {
+    chatModel(modelId: string): ChatModel;
+    embeddingModel(modelId: string): EmbeddingModel;
+    imageModel(modelId: string): ImageModel;
+};
+declare function createOpenAI(options?: OpenAIProviderOptions): OpenAIProvider;
+
+export { type OpenAIProvider, type OpenAIProviderOptions, createOpenAI };

package/dist/index.js

@@ -0,0 +1,422 @@
+// src/provider.ts
+import OpenAI from "openai";
+
+// src/chat-model.ts
+import { 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";
+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") {
+    return {
+      role: "assistant",
+      content: message.content,
+      ...message.toolCalls && message.toolCalls.length > 0 ? {
+        tool_calls: message.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 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 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 } : {},
+    ...options.providerOptions
+  };
+}
+function createStreamRequest(modelId, options) {
+  return {
+    model: modelId,
+    messages: convertMessages(options.messages),
+    stream: true,
+    stream_options: {
+      include_usage: true
+    },
+    ...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
+  };
+}
+function mapGenerateResponse(response) {
+  const firstChoice = response.choices[0];
+  if (!firstChoice) {
+    return {
+      content: null,
+      toolCalls: [],
+      finishReason: "unknown",
+      usage: {
+        inputTokens: 0,
+        outputTokens: 0,
+        reasoningTokens: 0,
+        totalTokens: 0
+      }
+    };
+  }
+  const reasoningTokens = response.usage?.completion_tokens_details?.reasoning_tokens ?? 0;
+  return {
+    content: firstChoice.message.content,
+    toolCalls: parseToolCalls(firstChoice.message.tool_calls),
+    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
+    }
+  };
+}
+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) {
+  const bufferedToolCalls = /* @__PURE__ */ new Map();
+  const emittedToolCalls = /* @__PURE__ */ new Set();
+  let finishReason = "unknown";
+  let usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    totalTokens: 0
+  };
+  for await (const chunk of stream) {
+    if (chunk.usage) {
+      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
+      };
+    }
+    const choice = chunk.choices[0];
+    if (!choice) {
+      continue;
+    }
+    if (choice.delta.content) {
+      yield {
+        type: "content-delta",
+        text: choice.delta.content
+      };
+    }
+    if (choice.delta.tool_calls) {
+      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") {
+      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 {
+    type: "finish",
+    finishReason,
+    usage
+  };
+}
+function safeParseJsonObject(json) {
+  try {
+    const parsed = JSON.parse(json);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function wrapError(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/chat-model.ts
+function createOpenAIChatModel(client, modelId) {
+  return {
+    provider: "openai",
+    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);
+      }
+    },
+    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);
+      }
+    }
+  };
+}
+
+// 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",
+    modelId,
+    async embed(options) {
+      try {
+        const response = await client.embeddings.create({
+          model: modelId,
+          input: options.input,
+          ...options.dimensions !== void 0 ? { dimensions: options.dimensions } : {},
+          ...options.providerOptions
+        });
+        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 wrapError2(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",
+    modelId,
+    async generate(options) {
+      try {
+        const request = {
+          model: modelId,
+          prompt: options.prompt,
+          ...options.n !== void 0 ? { n: options.n } : {},
+          ...options.size !== void 0 ? { size: options.size } : {},
+          ...options.providerOptions
+        };
+        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 wrapError3(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 = {}) {
+  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)
+  };
+}
+export {
+  createOpenAI
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "@core-ai/openai",
+    "version": "0.1.0",
+    "description": "OpenAI provider package for @core-ai/core-ai",
+    "license": "MIT",
+    "author": "Omnifact (https://omnifact.ai)",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/agdevhq/ai-core.git",
+        "directory": "packages/openai"
+    },
+    "keywords": ["llm", "ai", "openai", "provider", "sdk"],
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "files": ["dist", "README.md", "LICENSE"],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "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.1.0",
+        "openai": "^6.1.0",
+        "zod-to-json-schema": "^3.24.5"
+    },
+    "peerDependencies": {
+        "zod": "^3.25.76"
+    },
+    "devDependencies": {
+        "@core-ai/eslint-config": "^0.0.0",
+        "@core-ai/typescript-config": "^0.0.0",
+        "typescript": "^5.7.3",
+        "vitest": "^3.2.4"
+    }
+}