@arcote.tech/arc-ai-openai 0.4.9 → 0.5.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc-ai-openai",
   "type": "module",
-  "version": "0.4.9",
+  "version": "0.5.2",
   "private": false,
   "description": "OpenAI adapter for Arc AI framework",
   "main": "./src/index.ts",
@@ -10,7 +10,7 @@
     "type-check": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@arcote.tech/arc-ai": "^0.4.9",
+    "@arcote.tech/arc-ai": "^0.5.2",
     "typescript": "^5.0.0"
   },
   "devDependencies": {

package/src/index.ts

@@ -6,6 +6,7 @@ import type {
   ToolCall,
   TokenUsage,
   FinishReason,
+  Message,
 } from "@arcote.tech/arc-ai";
 
 // ─── Config ──────────────────────────────────────────────────────
@@ -16,7 +17,7 @@ export interface OpenAIConfig {
   defaultModel?: string;
 }
 
-// ─── Adapter ─────────────────────────────────────────────────────
+// ─── Adapter (Responses API) ────────────────────────────────────
 
 export function openai(config: OpenAIConfig): LLMProvider {
   const baseUrl = config.baseUrl ?? "https://api.openai.com/v1";
@@ -27,72 +28,130 @@ export function openai(config: OpenAIConfig): LLMProvider {
     if (!tools || tools.length === 0) return undefined;
     return tools.map((t) => ({
       type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters,
-      },
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters,
+      strict: false,
     }));
   }
 
-  function parseUsage(raw: any): TokenUsage {
-    const usage = raw.usage ?? {};
+  function parseUsage(usage: any): TokenUsage {
     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,
+      inputTokens: usage?.input_tokens ?? 0,
+      outputTokens: usage?.output_tokens ?? 0,
+      totalTokens: (usage?.input_tokens ?? 0) + (usage?.output_tokens ?? 0),
+      cachedTokens: usage?.input_tokens_details?.cached_tokens ?? 0,
+      reasoningTokens: usage?.output_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 buildInput(
+    messages: Message[],
+    previousResponseId?: string,
+  ): { instructions?: string; input: unknown; previous_response_id?: string } {
+    // Extract system message as instructions
+    const systemMsg = messages.find((m) => m.role === "system");
+    const nonSystemMessages = messages.filter((m) => m.role !== "system");
+
+    if (previousResponseId) {
+      // Continuation — send only new messages (tool results or new user message)
+      const newMessages = nonSystemMessages.filter(
+        (m) => m.role === "tool" || m === nonSystemMessages[nonSystemMessages.length - 1],
+      );
+
+      const input = newMessages.map((m) => {
+        if (m.role === "tool" && m.toolCallId) {
+          return {
+            type: "function_call_output",
+            call_id: m.toolCallId,
+            output: m.content,
+          };
+        }
+        return {
+          type: "message",
+          role: m.role,
+          content: m.content,
+        };
+      });
+
+      return {
+        instructions: systemMsg?.content,
+        input,
+        previous_response_id: previousResponseId,
+      };
+    }
+
+    // First call — send all messages
+    const input = nonSystemMessages.map((m) => ({
+      type: "message",
+      role: m.role === "tool" ? "user" : m.role,
+      content: m.content,
     }));
+
+    return {
+      instructions: systemMsg?.content,
+      input,
+    };
   }
 
-  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";
-    }
+  function extractToolCallsFromOutput(output: any[]): ToolCall[] {
+    return output
+      .filter((item: any) => item.type === "function_call")
+      .map((item: any) => {
+        let args: Record<string, unknown> = {};
+        try {
+          args = JSON.parse(item.arguments);
+        } catch {}
+        return {
+          id: item.call_id,
+          name: item.name,
+          arguments: args,
+        };
+      });
   }
 
-  async function complete(request: CompletionRequest): Promise<CompletionResult> {
+  function extractContentFromOutput(output: any[]): string {
+    return output
+      .filter((item: any) => item.type === "message")
+      .flatMap((item: any) =>
+        (item.content ?? [])
+          .filter((c: any) => c.type === "output_text")
+          .map((c: any) => c.text),
+      )
+      .join("");
+  }
+
+  async function complete(
+    request: CompletionRequest,
+  ): Promise<CompletionResult> {
+    const { instructions, input, previous_response_id } = buildInput(
+      request.messages,
+      request.previousResponseId,
+    );
+
     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,
+      input,
+      ...(instructions ? { instructions } : {}),
+      ...(previous_response_id ? { previous_response_id } : {}),
+      ...(request.temperature != null
+        ? { temperature: request.temperature }
+        : {}),
+      ...(request.maxTokens != null
+        ? { max_output_tokens: request.maxTokens }
+        : {}),
     };
 
     const tools = translateTools(request.tools);
     if (tools) body.tools = tools;
-
     if (request.webSearch) {
-      body.tools = [
-        ...(tools ?? []),
-        { type: "web_search_preview" },
-      ];
+      body.tools = [...(tools ?? []), { type: "web_search_preview" }];
+    }
+    if (request.toolChoice) {
+      body.tool_choice = request.toolChoice;
     }
 
-    const response = await fetch(`${baseUrl}/chat/completions`, {
+    const response = await fetch(`${baseUrl}/responses`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -106,14 +165,16 @@ export function openai(config: OpenAIConfig): LLMProvider {
       throw new Error(`OpenAI API error ${response.status}: ${error}`);
     }
 
-    const data = await response.json() as any;
-    const choice = data.choices[0];
+    const data = (await response.json());
+    const toolCalls = extractToolCallsFromOutput(data.output ?? []);
+    const hasToolCalls = toolCalls.length > 0;
 
     return {
-      content: choice.message?.content ?? "",
-      toolCalls: extractToolCalls(choice),
-      usage: parseUsage(data),
-      finishReason: mapFinishReason(choice.finish_reason),
+      content: extractContentFromOutput(data.output ?? []),
+      toolCalls,
+      usage: parseUsage(data.usage),
+      finishReason: hasToolCalls ? "tool_call" : "stop",
+      responseId: data.id,
     };
   }
 
@@ -121,31 +182,35 @@ export function openai(config: OpenAIConfig): LLMProvider {
     request: CompletionRequest,
     onChunk: (chunk: StreamChunk) => void,
   ): Promise<CompletionResult> {
+    const { instructions, input, previous_response_id } = buildInput(
+      request.messages,
+      request.previousResponseId,
+    );
+
     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,
+      input,
       stream: true,
-      stream_options: { include_usage: true },
+      ...(instructions ? { instructions } : {}),
+      ...(previous_response_id ? { previous_response_id } : {}),
+      ...(request.temperature != null
+        ? { temperature: request.temperature }
+        : {}),
+      ...(request.maxTokens != null
+        ? { max_output_tokens: request.maxTokens }
+        : {}),
     };
 
     const tools = translateTools(request.tools);
     if (tools) body.tools = tools;
-
     if (request.webSearch) {
-      body.tools = [
-        ...(tools ?? []),
-        { type: "web_search_preview" },
-      ];
+      body.tools = [...(tools ?? []), { type: "web_search_preview" }];
+    }
+    if (request.toolChoice) {
+      body.tool_choice = request.toolChoice;
     }
 
-    const response = await fetch(`${baseUrl}/chat/completions`, {
+    const response = await fetch(`${baseUrl}/responses`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -160,6 +225,7 @@ export function openai(config: OpenAIConfig): LLMProvider {
     }
 
     let content = "";
+    let responseId = "";
     let finishReason: FinishReason = "stop";
     let usage: TokenUsage = {
       inputTokens: 0,
@@ -168,11 +234,8 @@ export function openai(config: OpenAIConfig): LLMProvider {
       cachedTokens: 0,
       reasoningTokens: 0,
     };
-    const toolCallBuffers = new Map<
-      number,
-      { id: string; name: string; arguments: string }
-    >();
     const completedToolCalls: ToolCall[] = [];
+    const toolCallArgBuffers = new Map<string, string>();
 
     const reader = response.body!.getReader();
     const decoder = new TextDecoder();
@@ -189,79 +252,68 @@ export function openai(config: OpenAIConfig): LLMProvider {
       for (const line of lines) {
         if (!line.startsWith("data: ")) continue;
         const data = line.slice(6).trim();
-        if (data === "[DONE]") continue;
+        if (!data) 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 event = JSON.parse(data);
 
-          const delta = parsed.choices?.[0]?.delta;
-          if (!delta) continue;
+          switch (event.type) {
+            case "response.output_text.delta":
+              if (event.delta) {
+                content += event.delta;
+                onChunk({ type: "content_delta", content: event.delta });
+              }
+              break;
 
-          // Content delta
-          if (delta.content) {
-            content += delta.content;
-            onChunk({ type: "content_delta", content: delta.content });
-          }
+            case "response.function_call_arguments.delta":
+              if (event.call_id && event.delta) {
+                const existing = toolCallArgBuffers.get(event.call_id) ?? "";
+                toolCallArgBuffers.set(event.call_id, existing + event.delta);
+              }
+              break;
 
-          // 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 ?? "",
-                });
+            case "response.output_item.added":
+              if (event.item?.type === "function_call") {
+                toolCallArgBuffers.set(event.item.call_id, "");
                 onChunk({
                   type: "tool_call_start",
-                  toolCall: { id: tc.id, name: tc.function?.name ?? "", arguments: {} },
+                  toolCall: {
+                    id: event.item.call_id,
+                    name: event.item.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,
-                  });
-                }
               }
-            }
-          }
+              break;
+
+            case "response.output_item.done":
+              if (event.item?.type === "function_call") {
+                const buffered = toolCallArgBuffers.get(event.item.call_id);
+                const argsStr = (buffered && buffered.length > 0)
+                  ? buffered
+                  : (event.item.arguments ?? "{}");
+                let args: Record<string, unknown> = {};
+                try {
+                  args = JSON.parse(argsStr);
+                } catch {}
+                completedToolCalls.push({
+                  id: event.item.call_id,
+                  name: event.item.name,
+                  arguments: args,
+                });
+              }
+              break;
 
-          // Finish reason
-          const fr = parsed.choices?.[0]?.finish_reason;
-          if (fr) {
-            finishReason = mapFinishReason(fr);
+            case "response.completed":
+              responseId = event.response?.id ?? "";
+              usage = parseUsage(event.response?.usage);
+              onChunk({ type: "usage_update", usage });
 
-            // 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: {},
-                  });
-                }
+              // Extract content from completed response if not streamed
+              if (!content && event.response?.output) {
+                content = extractContentFromOutput(event.response.output);
               }
-            }
+              break;
           }
         } catch {
           // Skip malformed JSON
@@ -269,18 +321,33 @@ export function openai(config: OpenAIConfig): LLMProvider {
       }
     }
 
+    finishReason = completedToolCalls.length > 0 ? "tool_call" : "stop";
+
     return {
       content,
       toolCalls: completedToolCalls,
       usage,
       finishReason,
+      responseId,
     };
   }
 
+  const pricing: Record<string, { inputPer1M: number; outputPer1M: number; cachedInputPer1M?: number; reasoningPer1M?: number }> = {
+    "gpt-4o": { inputPer1M: 2.50, outputPer1M: 10.00, cachedInputPer1M: 1.25 },
+    "gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.60, cachedInputPer1M: 0.075 },
+    "o3": { inputPer1M: 10.00, outputPer1M: 40.00, reasoningPer1M: 40.00 },
+    "o3-mini": { inputPer1M: 1.10, outputPer1M: 4.40, reasoningPer1M: 4.40 },
+    "gpt-4.1": { inputPer1M: 2.00, outputPer1M: 8.00, cachedInputPer1M: 0.50 },
+    "gpt-4.1-mini": { inputPer1M: 0.40, outputPer1M: 1.60, cachedInputPer1M: 0.10 },
+    "gpt-4.1-nano": { inputPer1M: 0.10, outputPer1M: 0.40, cachedInputPer1M: 0.025 },
+    "gpt-5.4-nano": { inputPer1M: 0.10, outputPer1M: 0.40, cachedInputPer1M: 0.025 },
+  };
+
   return {
     name: "openai",
-    models: ["gpt-4o", "gpt-4o-mini", "o3", "o3-mini", "gpt-4.1", "gpt-4.1-mini", "gpt-4.1-nano"],
+    models: Object.keys(pricing),
     complete,
     streamComplete,
+    getPricing: (model: string) => pricing[model],
   };
 }