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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc-ai-openai",
   "type": "module",
-  "version": "0.5.2",
+  "version": "0.5.6",
   "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.2",
+    "@arcote.tech/arc-ai": "^0.5.6",
     "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 {
@@ -45,101 +49,89 @@ 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,
+        },
+      ];
+    }
 
-      return {
-        instructions: systemMsg?.content,
-        input,
-        previous_response_id: previousResponseId,
-      };
+    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,
+        },
+      ];
     }
 
-    // First call — send all messages
-    const input = nonSystemMessages.map((m) => ({
-      type: "message",
-      role: m.role === "tool" ? "user" : m.role,
-      content: m.content,
-    }));
+    // 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 {
+        input: conversation.turns.flatMap(turnToInputItems),
+      };
+    }
     return {
-      instructions: systemMsg?.content,
-      input,
+      input: conversation.newTurns.flatMap(turnToInputItems),
+      previous_response_id: conversation.previousResponseId,
     };
   }
 
-  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,
-        };
-      });
-  }
-
-  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,
-    );
+  function buildBody(request: CompletionRequest, stream: boolean): Record<string, unknown> {
+    const { input, previous_response_id } = buildInput(request.conversation);
 
     const body: Record<string, unknown> = {
       model: request.model,
       input,
-      ...(instructions ? { instructions } : {}),
+      // `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 }
-        : {}),
+      ...(request.temperature != null ? { temperature: request.temperature } : {}),
+      ...(request.maxTokens != null ? { max_output_tokens: request.maxTokens } : {}),
     };
 
     const tools = translateTools(request.tools);
@@ -151,6 +143,43 @@ export function openai(config: OpenAIConfig): LLMProvider {
       body.tool_choice = request.toolChoice;
     }
 
+    return body;
+  }
+
+  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 {}
+        blocks.push({
+          type: "tool_call",
+          id: item.call_id,
+          name: item.name,
+          arguments: args,
+        });
+      }
+    }
+    return blocks;
+  }
+
+  // ─── complete (non-streaming) ─────────────────────────────────
+
+  async function complete(
+    request: CompletionRequest,
+  ): Promise<CompletionResult> {
+    const body = buildBody(request, false);
+
     const response = await fetch(`${baseUrl}/responses`, {
       method: "POST",
       headers: {
@@ -165,50 +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" }];
-    }
-    if (request.toolChoice) {
-      body.tool_choice = request.toolChoice;
-    }
+    const body = buildBody(request, true);
 
     const response = await fetch(`${baseUrl}/responses`, {
       method: "POST",
@@ -224,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,
@@ -234,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();
@@ -258,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") {
-                const buffered = toolCallArgBuffers.get(event.item.call_id);
-                const argsStr = (buffered && buffered.length > 0)
-                  ? buffered
-                  : (event.item.arguments ?? "{}");
+            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 =
+                  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
@@ -321,31 +357,44 @@ 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.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 },
+  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: Object.keys(pricing),
+    supportsContinuation: true,
     complete,
     streamComplete,
     getPricing: (model: string) => pricing[model],