@arcote.tech/arc-ai-openai 0.7.12 → 0.7.13

package/package.json

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

package/src/index.ts

@@ -1,14 +1,17 @@
 import type {
-  LLMProvider,
+  ArcFileRef,
+  AssistantContentBlock,
+  BoundProviderFile,
   CompletionRequest,
   CompletionResult,
   Conversation,
   ConversationTurn,
-  AssistantContentBlock,
+  FileDownloader,
+  FinishReason,
+  LLMProvider,
   StreamChunk,
   ToolCall,
   TokenUsage,
-  FinishReason,
 } from "@arcote.tech/arc-ai";
 
 // ─── Config ──────────────────────────────────────────────────────
@@ -17,6 +20,13 @@ export interface OpenAIConfig {
   apiKey: string;
   baseUrl?: string;
   defaultModel?: string;
+  /**
+   * Opcjonalny downloader pobierający binary z S3 dla file attachmentów.
+   * Wymagany jeśli consumer wysyła `CompletionRequest.files` — adapter
+   * używa go w lazy upload do OpenAI Files API (`purpose=user_data`).
+   * Bez fileDownloadera + z `request.files` adapter rzuci jasny error.
+   */
+  fileDownloader?: FileDownloader;
 }
 
 // ─── Adapter (Responses API) ────────────────────────────────────
@@ -51,17 +61,31 @@ export function openai(config: OpenAIConfig): LLMProvider {
 
   /**
    * 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.
+   * input items, preserving block ordering for assistant turns.
+   *
+   * Jeśli `files` jest podany dla user turn, content staje się tablicą z
+   * `input_file` blockami przed `input_text`. Wywoływać tylko dla ostatniego
+   * user turn (pliki są attachmentem do tego konkretnego user message).
    */
-  function turnToInputItems(turn: ConversationTurn): unknown[] {
+  function turnToInputItems(
+    turn: ConversationTurn,
+    files?: ArcFileRef[],
+  ): unknown[] {
     if (turn.role === "user") {
+      const fileItems = (files ?? [])
+        .filter((f) => f.providerFileIds?.openai)
+        .map((f) => ({ type: "input_file", file_id: f.providerFileIds!.openai }));
+      if (fileItems.length === 0) {
+        return [{ type: "message", role: "user", content: turn.content }];
+      }
       return [
         {
           type: "message",
           role: "user",
-          content: turn.content,
+          content: [
+            ...fileItems,
+            { type: "input_text", text: turn.content },
+          ],
         },
       ];
     }
@@ -104,29 +128,48 @@ export function openai(config: OpenAIConfig): LLMProvider {
     return items;
   }
 
-  function buildInput(conversation: Conversation): {
-    input: unknown[];
-    previous_response_id?: string;
-  } {
-    if (conversation.mode === "full") {
-      return {
-        input: conversation.turns.flatMap(turnToInputItems),
-      };
+  function buildInput(
+    conversation: Conversation,
+    files?: ArcFileRef[],
+  ): { input: unknown[]; previous_response_id?: string } {
+    const turns =
+      conversation.mode === "full"
+        ? conversation.turns
+        : conversation.newTurns;
+
+    // Pliki idą do ostatniego user turn (najnowsza wiadomość usera).
+    // findLastIndex wymaga ES2023 — fallback przez reverse iteration.
+    let lastUserIdx = -1;
+    for (let i = turns.length - 1; i >= 0; i--) {
+      if (turns[i].role === "user") {
+        lastUserIdx = i;
+        break;
+      }
     }
-    return {
-      input: conversation.newTurns.flatMap(turnToInputItems),
-      previous_response_id: conversation.previousResponseId,
-    };
+
+    const input = turns.flatMap((turn, i) =>
+      turnToInputItems(turn, i === lastUserIdx ? files : undefined),
+    );
+
+    if (conversation.mode === "continuation") {
+      return { input, previous_response_id: conversation.previousResponseId };
+    }
+    return { input };
   }
 
-  function buildBody(request: CompletionRequest, stream: boolean): Record<string, unknown> {
-    const { input, previous_response_id } = buildInput(request.conversation);
+  function buildBody(
+    request: CompletionRequest,
+    stream: boolean,
+    enrichedFiles: ArcFileRef[],
+  ): Record<string, unknown> {
+    const { input, previous_response_id } = buildInput(
+      request.conversation,
+      enrichedFiles,
+    );
 
     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 } : {}),
@@ -176,12 +219,79 @@ export function openai(config: OpenAIConfig): LLMProvider {
     return blocks;
   }
 
+  // ─── File uploads (OpenAI Files API) ─────────────────────────
+
+  async function uploadFileToOpenAI(file: ArcFileRef): Promise<string> {
+    if (!config.fileDownloader) {
+      throw new Error(
+        `openai adapter received request.files but no fileDownloader was configured — wstrzyknij \`fileDownloader\` w openai({...})`,
+      );
+    }
+    const buffer = await config.fileDownloader.download(file.s3Key);
+    const form = new FormData();
+    form.append("purpose", "user_data");
+    // OpenAI Files API odrzuca `purpose=user_data` z generic
+    // `application/octet-stream` ("badly formatted or corrupted"). Jeśli
+    // upstream pickier nie wykrył mime z extension, pomijamy `type:` na
+    // Blob — OpenAI sam infer'uje typ z `filename` field formData.
+    const effectiveMime =
+      file.mime && file.mime !== "application/octet-stream" ? file.mime : "";
+    form.append(
+      "file",
+      new Blob([new Uint8Array(buffer)], effectiveMime ? { type: effectiveMime } : {}),
+      file.name,
+    );
+    const resp = await fetch(`${baseUrl}/files`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${config.apiKey}` },
+      body: form,
+    });
+    if (!resp.ok) {
+      const text = await resp.text();
+      throw new Error(`OpenAI Files API error ${resp.status}: ${text}`);
+    }
+    const data = await resp.json();
+    if (!data.id) throw new Error(`OpenAI Files API returned no id: ${JSON.stringify(data)}`);
+    return data.id as string;
+  }
+
+  /**
+   * Dla każdego pliku w request bez `providerFileIds.openai` robi lazy
+   * upload do OpenAI Files API. Zwraca:
+   *  - `enriched`: pliki z uzupełnionym `providerFileIds.openai` (do
+   *    użycia w `turnToInputItems`)
+   *  - `bound`: nowe binding'i (consumer zapisuje w aggregate'cie żeby
+   *    następne request'y nie powtarzały uploadu)
+   */
+  async function ensureFileIds(
+    files: ArcFileRef[] | undefined,
+  ): Promise<{ enriched: ArcFileRef[]; bound: BoundProviderFile[] }> {
+    if (!files || files.length === 0) return { enriched: [], bound: [] };
+    const enriched: ArcFileRef[] = [];
+    const bound: BoundProviderFile[] = [];
+    for (const f of files) {
+      const existing = f.providerFileIds?.openai;
+      if (existing) {
+        enriched.push(f);
+        continue;
+      }
+      const providerFileId = await uploadFileToOpenAI(f);
+      bound.push({ fileId: f.fileId, provider: "openai", providerFileId });
+      enriched.push({
+        ...f,
+        providerFileIds: { ...(f.providerFileIds ?? {}), openai: providerFileId },
+      });
+    }
+    return { enriched, bound };
+  }
+
   // ─── complete (non-streaming) ─────────────────────────────────
 
   async function complete(
     request: CompletionRequest,
   ): Promise<CompletionResult> {
-    const body = buildBody(request, false);
+    const { enriched, bound } = await ensureFileIds(request.files);
+    const body = buildBody(request, false, enriched);
 
     const response = await fetch(`${baseUrl}/responses`, {
       method: "POST",
@@ -206,6 +316,7 @@ export function openai(config: OpenAIConfig): LLMProvider {
       usage: parseUsage(data.usage),
       finishReason: hasToolCalls ? "tool_call" : "stop",
       responseId: data.id,
+      ...(bound.length > 0 ? { boundProviderFiles: bound } : {}),
     };
   }
 
@@ -215,7 +326,8 @@ export function openai(config: OpenAIConfig): LLMProvider {
     request: CompletionRequest,
     onChunk: (chunk: StreamChunk) => void,
   ): Promise<CompletionResult> {
-    const body = buildBody(request, true);
+    const { enriched, bound } = await ensureFileIds(request.files);
+    const body = buildBody(request, true, enriched);
 
     const response = await fetch(`${baseUrl}/responses`, {
       method: "POST",
@@ -287,7 +399,6 @@ export function openai(config: OpenAIConfig): LLMProvider {
                 orderedBlocks[idx] = block;
                 toolCallArgBuffers.set(item.call_id, "");
                 toolCallIndex.set(item.call_id, idx);
-                // Phase 1: tool call ujawniony — klient pokazuje "Przygotowuje: {name}…"
                 onChunk({
                   type: "tool_call_started",
                   toolCallId: item.call_id,
@@ -312,7 +423,6 @@ export function openai(config: OpenAIConfig): LLMProvider {
               if (event.call_id && event.delta) {
                 const existing = toolCallArgBuffers.get(event.call_id) ?? "";
                 toolCallArgBuffers.set(event.call_id, existing + event.delta);
-                // Phase 2: streaming JSON args — opcjonalne dla UI (loader).
                 onChunk({
                   type: "tool_call_arguments_delta",
                   toolCallId: event.call_id,
@@ -341,7 +451,6 @@ export function openai(config: OpenAIConfig): LLMProvider {
                     block.arguments = args;
                   }
                 }
-                // Phase 3: args complete — klient promotuje status do "executing".
                 onChunk({
                   type: "tool_call_arguments_complete",
                   toolCallId: item.call_id,
@@ -355,8 +464,6 @@ export function openai(config: OpenAIConfig): LLMProvider {
               responseId = event.response?.id ?? "";
               usage = parseUsage(event.response?.usage);
               onChunk({ type: "usage_update", usage });
-              // 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);
@@ -381,6 +488,7 @@ export function openai(config: OpenAIConfig): LLMProvider {
       usage,
       finishReason: hasToolCalls ? "tool_call" : "stop",
       responseId,
+      ...(bound.length > 0 ? { boundProviderFiles: bound } : {}),
     };
   }