@agentier/openai 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * OpenAI provider for the agenti framework.
+ *
+ * @packageDocumentation
+ */
+export { openai } from './provider';
+export type { OpenAIProviderConfig } from './types';

package/dist/index.js

@@ -0,0 +1,213 @@
+// src/mapper.ts
+function toOpenAIMessages(messages) {
+  return messages.map((msg) => {
+    const oaiMsg = {
+      role: msg.role,
+      content: msg.content
+    };
+    if (msg.toolCalls && msg.toolCalls.length > 0) {
+      oaiMsg.tool_calls = msg.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: tc.name,
+          arguments: JSON.stringify(tc.arguments)
+        }
+      }));
+    }
+    if (msg.toolCallId) {
+      oaiMsg.tool_call_id = msg.toolCallId;
+    }
+    if (msg.name) {
+      oaiMsg.name = msg.name;
+    }
+    return oaiMsg;
+  });
+}
+function toOpenAITools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }
+  }));
+}
+function fromOpenAIToolCalls(toolCalls) {
+  if (!toolCalls)
+    return [];
+  return toolCalls.map((tc) => ({
+    id: tc.id,
+    name: tc.function.name,
+    arguments: JSON.parse(tc.function.arguments)
+  }));
+}
+
+// src/provider.ts
+function openai(config) {
+  const baseUrl = (config.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
+  const fetchFn = config.fetch ?? globalThis.fetch;
+  function buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiKey}`,
+      ...config.defaultHeaders
+    };
+    if (config.organization) {
+      headers["OpenAI-Organization"] = config.organization;
+    }
+    return headers;
+  }
+  function buildBody(params, stream = false) {
+    const body = {
+      model: params.model,
+      messages: toOpenAIMessages(params.messages),
+      stream
+    };
+    if (params.tools && params.tools.length > 0) {
+      body.tools = toOpenAITools(params.tools);
+    }
+    if (params.temperature !== undefined)
+      body.temperature = params.temperature;
+    if (params.topP !== undefined)
+      body.top_p = params.topP;
+    if (params.maxOutputTokens !== undefined)
+      body.max_tokens = params.maxOutputTokens;
+    if (params.responseFormat) {
+      body.response_format = params.responseFormat;
+    }
+    return body;
+  }
+  const provider = {
+    name: "openai",
+    async chat(params) {
+      const response = await fetchFn(`${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: JSON.stringify(buildBody(params, false)),
+        signal: params.signal
+      });
+      if (!response.ok) {
+        const errorBody = await response.text();
+        throw new Error(`OpenAI API error (${response.status}): ${errorBody}`);
+      }
+      const data = await response.json();
+      const choice = data.choices[0];
+      return {
+        content: choice.message.content,
+        toolCalls: fromOpenAIToolCalls(choice.message.tool_calls),
+        usage: {
+          inputTokens: data.usage?.prompt_tokens ?? 0,
+          outputTokens: data.usage?.completion_tokens ?? 0
+        },
+        raw: data
+      };
+    },
+    async* stream(params) {
+      const response = await fetchFn(`${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: JSON.stringify(buildBody(params, true)),
+        signal: params.signal
+      });
+      if (!response.ok) {
+        const errorBody = await response.text();
+        throw new Error(`OpenAI API error (${response.status}): ${errorBody}`);
+      }
+      const reader = response.body?.getReader();
+      if (!reader)
+        throw new Error("No response body");
+      const decoder = new TextDecoder;
+      let buffer = "";
+      let fullContent = "";
+      const toolCallBuffers = new Map;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split(`
+`);
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith("data: "))
+              continue;
+            const data = trimmed.slice(6);
+            if (data === "[DONE]")
+              continue;
+            try {
+              const parsed = JSON.parse(data);
+              const delta = parsed.choices?.[0]?.delta;
+              if (!delta)
+                continue;
+              if (delta.content) {
+                fullContent += delta.content;
+                yield { type: "token", text: delta.content };
+              }
+              if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                  const idx = tc.index ?? 0;
+                  if (tc.id) {
+                    toolCallBuffers.set(idx, {
+                      id: tc.id,
+                      name: tc.function?.name ?? "",
+                      args: tc.function?.arguments ?? ""
+                    });
+                    yield {
+                      type: "tool_call_start",
+                      id: tc.id,
+                      name: tc.function?.name ?? ""
+                    };
+                  } else {
+                    const existing = toolCallBuffers.get(idx);
+                    if (existing && tc.function?.arguments) {
+                      existing.args += tc.function.arguments;
+                      yield {
+                        type: "tool_call_delta",
+                        id: existing.id,
+                        argumentsDelta: tc.function.arguments
+                      };
+                    }
+                  }
+                }
+              }
+              if (parsed.usage) {
+                inputTokens = parsed.usage.prompt_tokens ?? inputTokens;
+                outputTokens = parsed.usage.completion_tokens ?? outputTokens;
+              }
+            } catch {}
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+      const toolCalls = [];
+      for (const [, tc] of toolCallBuffers) {
+        const call = {
+          id: tc.id,
+          name: tc.name,
+          arguments: tc.args ? JSON.parse(tc.args) : {}
+        };
+        toolCalls.push(call);
+        yield { type: "tool_call_end", id: tc.id, call };
+      }
+      yield {
+        type: "done",
+        response: {
+          content: fullContent || null,
+          toolCalls,
+          usage: { inputTokens, outputTokens }
+        }
+      };
+    }
+  };
+  return provider;
+}
+export {
+  openai
+};

package/dist/mapper.d.ts

@@ -0,0 +1,53 @@
+import type { Message, ToolCall, ToolJsonSchema } from '@agentier/core';
+/** Wire format for an OpenAI chat message. */
+export interface OpenAIMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | null;
+    tool_calls?: OpenAIToolCall[];
+    tool_call_id?: string;
+    name?: string;
+}
+/** Wire format for an OpenAI tool call within an assistant message. */
+export interface OpenAIToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        /** JSON-encoded arguments string. */
+        arguments: string;
+    };
+}
+/** Wire format for an OpenAI tool (function) definition. */
+export interface OpenAITool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+/**
+ * Converts agenti `Message` objects into the OpenAI chat completions message format.
+ *
+ * Handles tool calls, tool call IDs, and optional message names.
+ *
+ * @param messages - Array of provider-agnostic messages.
+ * @returns Array of OpenAI-formatted messages ready for the API.
+ */
+export declare function toOpenAIMessages(messages: Message[]): OpenAIMessage[];
+/**
+ * Converts agenti tool schemas into the OpenAI function-calling tool format.
+ *
+ * @param tools - Array of provider-agnostic tool JSON schemas.
+ * @returns Array of OpenAI tool definitions.
+ */
+export declare function toOpenAITools(tools: ToolJsonSchema[]): OpenAITool[];
+/**
+ * Converts OpenAI tool calls from a response back into agenti `ToolCall` objects.
+ *
+ * Parses the JSON-encoded `arguments` string in each tool call.
+ *
+ * @param toolCalls - Optional array of OpenAI tool calls from the API response.
+ * @returns Array of agenti tool calls, or an empty array if none were provided.
+ */
+export declare function fromOpenAIToolCalls(toolCalls?: OpenAIToolCall[]): ToolCall[];

package/dist/provider.d.ts

@@ -0,0 +1,24 @@
+import type { ModelProvider } from '@agentier/core';
+import type { OpenAIProviderConfig } from './types';
+/**
+ * Creates an OpenAI-compatible {@link ModelProvider}.
+ *
+ * Supports both blocking `chat` and streaming `stream` completions via the
+ * `/chat/completions` endpoint. Works with any OpenAI-compatible API by
+ * overriding `baseUrl` in the config.
+ *
+ * @param config - Provider configuration including API key and optional overrides.
+ * @returns A `ModelProvider` wired to the OpenAI chat completions API.
+ *
+ * @example
+ * ```ts
+ * import { openai } from '@agentier/provider-openai'
+ *
+ * const provider = openai({ apiKey: process.env.OPENAI_API_KEY! })
+ * const response = await provider.chat({
+ *   model: 'gpt-4o',
+ *   messages: [{ role: 'user', content: 'Hello!' }],
+ * })
+ * ```
+ */
+export declare function openai(config: OpenAIProviderConfig): ModelProvider;

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Configuration for the OpenAI provider.
+ *
+ * @example
+ * ```ts
+ * const config: OpenAIProviderConfig = {
+ *   apiKey: process.env.OPENAI_API_KEY!,
+ *   organization: 'org-abc123',
+ * }
+ * ```
+ */
+export interface OpenAIProviderConfig {
+    /** OpenAI API key used for authentication. */
+    apiKey: string;
+    /** Base URL for API requests. Defaults to `https://api.openai.com/v1`. */
+    baseUrl?: string;
+    /** OpenAI organization ID sent via the `OpenAI-Organization` header. */
+    organization?: string;
+    /** Additional headers merged into every request. */
+    defaultHeaders?: Record<string, string>;
+    /** Custom `fetch` implementation, useful for proxies or test doubles. */
+    fetch?: typeof globalThis.fetch;
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "@agentier/openai",
+    "version": "0.1.0",
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "bun build ./src/index.ts --outdir ./dist --target node",
+        "test": "bun test",
+        "typecheck": "tsc --noEmit"
+    },
+    "peerDependencies": {
+        "@agentier/core": "^0.1.0"
+    },
+    "devDependencies": {
+        "@agentier/core": "workspace:*",
+        "typescript": "^5.5.0",
+        "@types/bun": "latest"
+    }
+}