@arcote.tech/arc-ai-openai 0.5.0 → 0.5.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc-ai-openai",
   "type": "module",
-  "version": "0.5.0",
+  "version": "0.5.5",
   "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.5.0",
+    "@arcote.tech/arc-ai": "^0.5.5",
     "typescript": "^5.0.0"
   },
   "devDependencies": {

package/src/index.ts

@@ -2,11 +2,13 @@ import type {
   LLMProvider,
   CompletionRequest,
   CompletionResult,
+  Conversation,
+  ConversationTurn,
+  AssistantContentBlock,
   StreamChunk,
   ToolCall,
   TokenUsage,
   FinishReason,
-  Message,
 } from "@arcote.tech/arc-ai";
 
 // ─── Config ──────────────────────────────────────────────────────
@@ -22,6 +24,8 @@ export interface OpenAIConfig {
 export function openai(config: OpenAIConfig): LLMProvider {
   const baseUrl = config.baseUrl ?? "https://api.openai.com/v1";
 
+  // ─── Helpers ──────────────────────────────────────────────────
+
   function translateTools(
     tools: CompletionRequest["tools"],
   ): unknown[] | undefined {
@@ -31,6 +35,7 @@ export function openai(config: OpenAIConfig): LLMProvider {
       name: t.name,
       description: t.description,
       parameters: t.parameters,
+      strict: false,
     }));
   }
 
@@ -44,108 +49,136 @@ export function openai(config: OpenAIConfig): LLMProvider {
     };
   }
 
-  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 {
+  /**
+   * Translate a single ConversationTurn into one or more OpenAI Responses API
+   * input items, preserving block ordering for assistant turns. Adapter is a
+   * pure translator — caller already decided what to send via the
+   * Conversation discriminated union.
+   */
+  function turnToInputItems(turn: ConversationTurn): unknown[] {
+    if (turn.role === "user") {
+      return [
+        {
           type: "message",
-          role: m.role,
-          content: m.content,
-        };
-      });
+          role: "user",
+          content: turn.content,
+        },
+      ];
+    }
 
+    if (turn.role === "tool_result") {
+      // OpenAI Responses API requires `output` to be a string. If upstream
+      // deserialized our JSON-shaped content into an object, re-stringify.
+      const output =
+        typeof turn.content === "string"
+          ? turn.content
+          : JSON.stringify(turn.content);
+      return [
+        {
+          type: "function_call_output",
+          call_id: turn.toolCallId,
+          output,
+        },
+      ];
+    }
+
+    // assistant — emit blocks in order, mapping each block to its OpenAI shape
+    const items: unknown[] = [];
+    for (const block of turn.blocks) {
+      if (block.type === "text") {
+        if (!block.text) continue;
+        items.push({
+          type: "message",
+          role: "assistant",
+          content: block.text,
+        });
+      } else {
+        items.push({
+          type: "function_call",
+          call_id: block.id,
+          name: block.name,
+          arguments: JSON.stringify(block.arguments),
+        });
+      }
+    }
+    return items;
+  }
+
+  function buildInput(conversation: Conversation): {
+    input: unknown[];
+    previous_response_id?: string;
+  } {
+    if (conversation.mode === "full") {
       return {
-        instructions: systemMsg?.content,
-        input,
-        previous_response_id: previousResponseId,
+        input: conversation.turns.flatMap(turnToInputItems),
       };
     }
+    return {
+      input: conversation.newTurns.flatMap(turnToInputItems),
+      previous_response_id: conversation.previousResponseId,
+    };
+  }
 
-    // First call — send all messages
-    const input = nonSystemMessages.map((m) => ({
-      type: "message",
-      role: m.role === "tool" ? "user" : m.role,
-      content: m.content,
-    }));
+  function buildBody(request: CompletionRequest, stream: boolean): Record<string, unknown> {
+    const { input, previous_response_id } = buildInput(request.conversation);
 
-    return {
-      instructions: systemMsg?.content,
+    const body: Record<string, unknown> = {
+      model: request.model,
       input,
+      // `instructions` is sent on every call. With previous_response_id it
+      // replaces the prior server-side instructions for this turn.
+      instructions: request.instructions,
+      ...(stream ? { stream: true } : {}),
+      ...(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" }];
+    }
+    if (request.toolChoice) {
+      body.tool_choice = request.toolChoice;
+    }
+
+    return body;
   }
 
-  function extractToolCallsFromOutput(output: any[]): ToolCall[] {
-    return output
-      .filter((item: any) => item.type === "function_call")
-      .map((item: any) => {
+  function blocksFromOutput(output: any[]): AssistantContentBlock[] {
+    const blocks: AssistantContentBlock[] = [];
+    for (const item of output ?? []) {
+      if (item.type === "message") {
+        const text = (item.content ?? [])
+          .filter((c: any) => c.type === "output_text")
+          .map((c: any) => c.text)
+          .join("");
+        if (text) blocks.push({ type: "text", text });
+        continue;
+      }
+      if (item.type === "function_call") {
         let args: Record<string, unknown> = {};
         try {
           args = JSON.parse(item.arguments);
         } catch {}
-        return {
+        blocks.push({
+          type: "tool_call",
           id: item.call_id,
           name: item.name,
           arguments: args,
-        };
-      });
+        });
+      }
+    }
+    return blocks;
   }
 
-  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("");
-  }
+  // ─── complete (non-streaming) ─────────────────────────────────
 
   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,
-      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" }];
-    }
+    const body = buildBody(request, false);
 
     const response = await fetch(`${baseUrl}/responses`, {
       method: "POST",
@@ -161,47 +194,25 @@ export function openai(config: OpenAIConfig): LLMProvider {
       throw new Error(`OpenAI API error ${response.status}: ${error}`);
     }
 
-    const data = (await response.json());
-    const toolCalls = extractToolCallsFromOutput(data.output ?? []);
-    const hasToolCalls = toolCalls.length > 0;
+    const data = await response.json();
+    const blocks = blocksFromOutput(data.output ?? []);
+    const hasToolCalls = blocks.some((b) => b.type === "tool_call");
 
     return {
-      content: extractContentFromOutput(data.output ?? []),
-      toolCalls,
+      blocks,
       usage: parseUsage(data.usage),
       finishReason: hasToolCalls ? "tool_call" : "stop",
       responseId: data.id,
     };
   }
 
+  // ─── streamComplete ───────────────────────────────────────────
+
   async function streamComplete(
     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,
-      input,
-      stream: 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" }];
-    }
+    const body = buildBody(request, true);
 
     const response = await fetch(`${baseUrl}/responses`, {
       method: "POST",
@@ -217,9 +228,15 @@ export function openai(config: OpenAIConfig): LLMProvider {
       throw new Error(`OpenAI API error ${response.status}: ${error}`);
     }
 
-    let content = "";
+    // Reconstruct ordered blocks from streamed events. The Responses API
+    // emits output_item.added/done events in order, so we keep an array
+    // anchored by output_index for deterministic placement.
+    const orderedBlocks: AssistantContentBlock[] = [];
+    const indexToBlock = new Map<number, AssistantContentBlock>();
+    const toolCallArgBuffers = new Map<string, string>();
+    const toolCallIndex = new Map<string, number>();
+
     let responseId = "";
-    let finishReason: FinishReason = "stop";
     let usage: TokenUsage = {
       inputTokens: 0,
       outputTokens: 0,
@@ -227,8 +244,6 @@ export function openai(config: OpenAIConfig): LLMProvider {
       cachedTokens: 0,
       reasoningTokens: 0,
     };
-    const completedToolCalls: ToolCall[] = [];
-    const toolCallArgBuffers = new Map<string, string>();
 
     const reader = response.body!.getReader();
     const decoder = new TextDecoder();
@@ -251,62 +266,90 @@ export function openai(config: OpenAIConfig): LLMProvider {
           const event = JSON.parse(data);
 
           switch (event.type) {
-            case "response.output_text.delta":
-              if (event.delta) {
-                content += event.delta;
-                onChunk({ type: "content_delta", content: event.delta });
-              }
-              break;
-
-            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;
-
-            case "response.output_item.added":
-              if (event.item?.type === "function_call") {
-                toolCallArgBuffers.set(event.item.call_id, "");
+            case "response.output_item.added": {
+              const item = event.item;
+              const idx = event.output_index ?? orderedBlocks.length;
+              if (item?.type === "message") {
+                const block: AssistantContentBlock = { type: "text", text: "" };
+                indexToBlock.set(idx, block);
+                orderedBlocks[idx] = block;
+              } else if (item?.type === "function_call") {
+                const block: AssistantContentBlock = {
+                  type: "tool_call",
+                  id: item.call_id,
+                  name: item.name,
+                  arguments: {},
+                };
+                indexToBlock.set(idx, block);
+                orderedBlocks[idx] = block;
+                toolCallArgBuffers.set(item.call_id, "");
+                toolCallIndex.set(item.call_id, idx);
                 onChunk({
                   type: "tool_call_start",
                   toolCall: {
-                    id: event.item.call_id,
-                    name: event.item.name,
+                    id: item.call_id,
+                    name: item.name,
                     arguments: {},
                   },
                 });
               }
               break;
+            }
+
+            case "response.output_text.delta": {
+              if (!event.delta) break;
+              const idx = event.output_index;
+              const block = indexToBlock.get(idx);
+              if (block?.type === "text") {
+                block.text += event.delta;
+              }
+              onChunk({ type: "content_delta", content: event.delta });
+              break;
+            }
 
-            case "response.output_item.done":
-              if (event.item?.type === "function_call") {
+            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;
+            }
+
+            case "response.output_item.done": {
+              const item = event.item;
+              if (item?.type === "function_call") {
+                const buffered = toolCallArgBuffers.get(item.call_id);
                 const argsStr =
-                  toolCallArgBuffers.get(event.item.call_id) ??
-                  event.item.arguments ??
-                  "{}";
+                  buffered && buffered.length > 0
+                    ? buffered
+                    : 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,
-                });
+                const idx = toolCallIndex.get(item.call_id);
+                if (idx != null) {
+                  const block = indexToBlock.get(idx);
+                  if (block?.type === "tool_call") {
+                    block.arguments = args;
+                  }
+                }
               }
               break;
+            }
 
-            case "response.completed":
+            case "response.completed": {
               responseId = event.response?.id ?? "";
               usage = parseUsage(event.response?.usage);
               onChunk({ type: "usage_update", usage });
-
-              // Extract content from completed response if not streamed
-              if (!content && event.response?.output) {
-                content = extractContentFromOutput(event.response.output);
+              // Final reconciliation: if our streaming reconstruction missed
+              // anything, fall back to the completed output.
+              if (orderedBlocks.length === 0 && event.response?.output) {
+                const fallback = blocksFromOutput(event.response.output);
+                orderedBlocks.push(...fallback);
               }
               break;
+            }
           }
         } catch {
           // Skip malformed JSON
@@ -314,30 +357,46 @@ export function openai(config: OpenAIConfig): LLMProvider {
       }
     }
 
-    finishReason = completedToolCalls.length > 0 ? "tool_call" : "stop";
+    // Compact: drop any holes in orderedBlocks (defensive)
+    const blocks = orderedBlocks.filter(
+      (b): b is AssistantContentBlock => b != null,
+    );
+    const hasToolCalls = blocks.some((b) => b.type === "tool_call");
 
     return {
-      content,
-      toolCalls: completedToolCalls,
+      blocks,
       usage,
-      finishReason,
+      finishReason: hasToolCalls ? "tool_call" : "stop",
       responseId,
     };
   }
 
+  const pricing: Record<
+    string,
+    {
+      inputPer1M: number;
+      outputPer1M: number;
+      cachedInputPer1M?: number;
+      reasoningPer1M?: number;
+    }
+  > = {
+    "gpt-4o": { inputPer1M: 2.5, outputPer1M: 10.0, cachedInputPer1M: 1.25 },
+    "gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.6, cachedInputPer1M: 0.075 },
+    o3: { inputPer1M: 10.0, outputPer1M: 40.0, reasoningPer1M: 40.0 },
+    "o3-mini": { inputPer1M: 1.1, outputPer1M: 4.4, reasoningPer1M: 4.4 },
+    "gpt-4.1": { inputPer1M: 2.0, outputPer1M: 8.0, cachedInputPer1M: 0.5 },
+    "gpt-4.1-mini": { inputPer1M: 0.4, outputPer1M: 1.6, cachedInputPer1M: 0.1 },
+    "gpt-4.1-nano": { inputPer1M: 0.1, outputPer1M: 0.4, cachedInputPer1M: 0.025 },
+    "gpt-5.4-nano": { inputPer1M: 0.1, outputPer1M: 0.4, cachedInputPer1M: 0.025 },
+    "gpt-5.4-mini": { inputPer1M: 0.4, outputPer1M: 1.6, cachedInputPer1M: 0.1 },
+  };
+
   return {
     name: "openai",
-    models: [
-      "gpt-4o",
-      "gpt-4o-mini",
-      "o3",
-      "o3-mini",
-      "gpt-4.1",
-      "gpt-4.1-mini",
-      "gpt-4.1-nano",
-      "gpt-5.4-nano",
-    ],
+    models: Object.keys(pricing),
+    supportsContinuation: true,
     complete,
     streamComplete,
+    getPricing: (model: string) => pricing[model],
   };
 }