@arcote.tech/arc-ai-openai 0.4.6

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@arcote.tech/arc-ai-openai",
+  "type": "module",
+  "version": "0.4.6",
+  "private": false,
+  "description": "OpenAI adapter for Arc AI framework",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "scripts": {
+    "type-check": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@arcote.tech/arc-ai": "^0.4.6",
+    "typescript": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}

package/src/index.ts

@@ -0,0 +1,286 @@
+import type {
+  LLMProvider,
+  CompletionRequest,
+  CompletionResult,
+  StreamChunk,
+  ToolCall,
+  TokenUsage,
+  FinishReason,
+} from "@arcote.tech/arc-ai";
+
+// ─── Config ──────────────────────────────────────────────────────
+
+export interface OpenAIConfig {
+  apiKey: string;
+  baseUrl?: string;
+  defaultModel?: string;
+}
+
+// ─── Adapter ─────────────────────────────────────────────────────
+
+export function openai(config: OpenAIConfig): LLMProvider {
+  const baseUrl = config.baseUrl ?? "https://api.openai.com/v1";
+
+  function translateTools(
+    tools: CompletionRequest["tools"],
+  ): unknown[] | undefined {
+    if (!tools || tools.length === 0) return undefined;
+    return tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters,
+      },
+    }));
+  }
+
+  function parseUsage(raw: any): TokenUsage {
+    const usage = raw.usage ?? {};
+    return {
+      inputTokens: usage.prompt_tokens ?? 0,
+      outputTokens: usage.completion_tokens ?? 0,
+      totalTokens: usage.total_tokens ?? 0,
+      cachedTokens: usage.prompt_tokens_details?.cached_tokens ?? 0,
+      reasoningTokens:
+        usage.completion_tokens_details?.reasoning_tokens ?? 0,
+    };
+  }
+
+  function extractToolCalls(choice: any): ToolCall[] {
+    const toolCalls = choice.message?.tool_calls ?? [];
+    return toolCalls.map((tc: any) => ({
+      id: tc.id,
+      name: tc.function.name,
+      arguments: JSON.parse(tc.function.arguments),
+    }));
+  }
+
+  function mapFinishReason(reason: string): FinishReason {
+    switch (reason) {
+      case "stop":
+        return "stop";
+      case "tool_calls":
+        return "tool_call";
+      case "length":
+        return "max_tokens";
+      default:
+        return "stop";
+    }
+  }
+
+  async function complete(request: CompletionRequest): Promise<CompletionResult> {
+    const body: Record<string, unknown> = {
+      model: request.model,
+      messages: request.messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+        ...(m.name ? { name: m.name } : {}),
+        ...(m.toolCallId ? { tool_call_id: m.toolCallId } : {}),
+      })),
+      temperature: request.temperature,
+      max_tokens: request.maxTokens,
+    };
+
+    const tools = translateTools(request.tools);
+    if (tools) body.tools = tools;
+
+    if (request.webSearch) {
+      body.tools = [
+        ...(tools ?? []),
+        { type: "web_search_preview" },
+      ];
+    }
+
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.apiKey}`,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error ${response.status}: ${error}`);
+    }
+
+    const data = await response.json() as any;
+    const choice = data.choices[0];
+
+    return {
+      content: choice.message?.content ?? "",
+      toolCalls: extractToolCalls(choice),
+      usage: parseUsage(data),
+      finishReason: mapFinishReason(choice.finish_reason),
+    };
+  }
+
+  async function streamComplete(
+    request: CompletionRequest,
+    onChunk: (chunk: StreamChunk) => void,
+  ): Promise<CompletionResult> {
+    const body: Record<string, unknown> = {
+      model: request.model,
+      messages: request.messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+        ...(m.name ? { name: m.name } : {}),
+        ...(m.toolCallId ? { tool_call_id: m.toolCallId } : {}),
+      })),
+      temperature: request.temperature,
+      max_tokens: request.maxTokens,
+      stream: true,
+      stream_options: { include_usage: true },
+    };
+
+    const tools = translateTools(request.tools);
+    if (tools) body.tools = tools;
+
+    if (request.webSearch) {
+      body.tools = [
+        ...(tools ?? []),
+        { type: "web_search_preview" },
+      ];
+    }
+
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.apiKey}`,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error ${response.status}: ${error}`);
+    }
+
+    let content = "";
+    let finishReason: FinishReason = "stop";
+    let usage: TokenUsage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      cachedTokens: 0,
+      reasoningTokens: 0,
+    };
+    const toolCallBuffers = new Map<
+      number,
+      { id: string; name: string; arguments: string }
+    >();
+    const completedToolCalls: ToolCall[] = [];
+
+    const reader = response.body!.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop()!;
+
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (data === "[DONE]") continue;
+
+        try {
+          const parsed = JSON.parse(data);
+
+          // Usage-only chunk (last chunk)
+          if (parsed.usage && !parsed.choices?.length) {
+            usage = parseUsage(parsed);
+            onChunk({ type: "usage_update", usage });
+            continue;
+          }
+
+          const delta = parsed.choices?.[0]?.delta;
+          if (!delta) continue;
+
+          // Content delta
+          if (delta.content) {
+            content += delta.content;
+            onChunk({ type: "content_delta", content: delta.content });
+          }
+
+          // Tool call chunks (arguments arrive fragmented)
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const idx = tc.index;
+              if (tc.id) {
+                // First chunk for this tool call
+                toolCallBuffers.set(idx, {
+                  id: tc.id,
+                  name: tc.function?.name ?? "",
+                  arguments: tc.function?.arguments ?? "",
+                });
+                onChunk({
+                  type: "tool_call_start",
+                  toolCall: { id: tc.id, name: tc.function?.name ?? "", arguments: {} },
+                });
+              } else {
+                // Continuation chunk
+                const buf = toolCallBuffers.get(idx);
+                if (buf && tc.function?.arguments) {
+                  buf.arguments += tc.function.arguments;
+                  onChunk({
+                    type: "tool_call_delta",
+                    content: tc.function.arguments,
+                  });
+                }
+              }
+            }
+          }
+
+          // Finish reason
+          const fr = parsed.choices?.[0]?.finish_reason;
+          if (fr) {
+            finishReason = mapFinishReason(fr);
+
+            // Finalize tool calls
+            if (fr === "tool_calls") {
+              for (const buf of toolCallBuffers.values()) {
+                try {
+                  completedToolCalls.push({
+                    id: buf.id,
+                    name: buf.name,
+                    arguments: JSON.parse(buf.arguments),
+                  });
+                } catch {
+                  completedToolCalls.push({
+                    id: buf.id,
+                    name: buf.name,
+                    arguments: {},
+                  });
+                }
+              }
+            }
+          }
+        } catch {
+          // Skip malformed JSON
+        }
+      }
+    }
+
+    return {
+      content,
+      toolCalls: completedToolCalls,
+      usage,
+      finishReason,
+    };
+  }
+
+  return {
+    name: "openai",
+    models: ["gpt-4o", "gpt-4o-mini", "o3", "o3-mini", "gpt-4.1", "gpt-4.1-mini", "gpt-4.1-nano"],
+    complete,
+    streamComplete,
+  };
+}

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../../../tsconfig.json",
+  "include": ["src/**/*"]
+}