@arcote.tech/arc-chat 0.7.12 → 0.7.13

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc-chat",
   "type": "module",
-  "version": "0.7.12",
+  "version": "0.7.13",
   "private": false,
   "description": "Chat module with AI integration for Arc framework",
   "main": "./src/index.ts",
@@ -10,12 +10,12 @@
     "type-check": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@arcote.tech/arc": "^0.7.12",
-    "@arcote.tech/arc-ai": "^0.7.12",
-    "@arcote.tech/arc-ai-voice": "^0.7.12",
-    "@arcote.tech/arc-auth": "^0.7.12",
-    "@arcote.tech/arc-ds": "^0.7.12",
-    "@arcote.tech/platform": "^0.7.12",
+    "@arcote.tech/arc": "^0.7.13",
+    "@arcote.tech/arc-ai": "^0.7.13",
+    "@arcote.tech/arc-ai-voice": "^0.7.13",
+    "@arcote.tech/arc-auth": "^0.7.13",
+    "@arcote.tech/arc-ds": "^0.7.13",
+    "@arcote.tech/platform": "^0.7.13",
     "lucide-react": ">=0.400.0",
     "react": ">=18.0.0",
     "typescript": "^5.0.0"

package/src/aggregates/message.ts

@@ -100,6 +100,13 @@ export const createMessageAggregate = <
          * otwiera SSE i streaming jest visible od pierwszego chunka.
          */
         assistantMessageId: messageId.optional(),
+        /**
+         * JSON-encoded `string[]` z fileId'ami arc-files attachmentów do tej
+         * konkretnej wiadomości. Listener AI generation ładuje `ArcFile`
+         * records i przekazuje je w `CompletionRequest.files`. Nie zapisujemy
+         * w aggregate fields — flow jest read-once przez listener z event.
+         */
+        attachmentsJson: string().optional(),
       },
       async (ctx, event) => {
         const p = event.payload;
@@ -253,6 +260,12 @@ export const createMessageAggregate = <
         scopeId,
         content: string().minLength(1),
         model: string(),
+        /**
+         * Opcjonalna JSON-encoded `string[]` z fileId'ami arc-files
+         * dołączonymi do user message. Listener AI generation ładuje
+         * pełne records po stronie serwera.
+         */
+        attachmentsJson: string().optional(),
       }).handle(
         ONLY_SERVER &&
         (async (ctx, params) => {
@@ -282,6 +295,7 @@ export const createMessageAggregate = <
             content: params.content,
             model: params.model,
             assistantMessageId: assistantMsgId,
+            attachmentsJson: params.attachmentsJson,
           });
 
           return { messageId: userMsgId, sessionId, assistantMessageId: assistantMsgId };

package/src/chat-builder.ts

@@ -85,6 +85,17 @@ export interface ArcChatData {
   toolChoice: "auto" | "required" | { type: "function"; name: string };
   alias: string | null;
   billTo: BillToFn | null;
+  /**
+   * `arc-files` aggregate dla file attachmentów (PDF/DOCX/...) do user
+   * messages. Gdy ustawione, listener AI generation:
+   *   - ładuje `ArcFile` records po fileId'ach z `attachmentsJson` user msg,
+   *   - przekazuje je w `CompletionRequest.files`,
+   *   - po complete cachuje `boundProviderFiles` w aggregate'cie (lazy
+   *     upload do OpenAI Files API → file_id zapisany w `providerFileIdsJson`).
+   *
+   * Consumer wstrzykuje przez `.attachFiles({ File })`.
+   */
+  attachFiles: { File: any } | null;
 }
 
 const defaultChatData = {
@@ -101,6 +112,7 @@ const defaultChatData = {
   toolChoice: "auto" as const,
   alias: null,
   billTo: null,
+  attachFiles: null,
 } as const satisfies ArcChatData;
 
 type DefaultChatData = typeof defaultChatData;
@@ -237,6 +249,22 @@ export class ArcChat<const Data extends ArcChatData = DefaultChatData> {
     } as any);
   }
 
+  /**
+   * Włącza obsługę file attachments dla user messages — listener AI
+   * generation będzie ładował `ArcFile` records, przekazywał je w
+   * `CompletionRequest.files`, i cachował lazy-uploadowane `file_id`'y
+   * provider'ów (OpenAI Files API).
+   *
+   *   const files = arcFiles({ name: "ndt", scopeId: workspaceId, ... });
+   *   chat("identity").attachFiles({ File: files.File }).build();
+   */
+  attachFiles(config: { File: any }): ArcChat<Data> {
+    return new ArcChat<Data>({
+      ...this.data,
+      attachFiles: config,
+    } as any);
+  }
+
   build() {
     const {
       name,
@@ -252,6 +280,7 @@ export class ArcChat<const Data extends ArcChatData = DefaultChatData> {
       toolChoice,
       alias: aliasOverride,
       billTo,
+      attachFiles,
     } = this.data;
 
     if (!name) throw new Error("ArcChat: name is required");
@@ -319,6 +348,54 @@ export class ArcChat<const Data extends ArcChatData = DefaultChatData> {
       }
     }
 
+    // Attachments bridge — gdy chat woła `.attachFiles({File})`, dodajemy
+    // File aggregate do query/mutation deps i budujemy callbacks używane
+    // przez listener do: (a) load ArcFile records dla user attachmentów,
+    // (b) cache providerFileId po lazy upload.
+    let attachmentsBridge: any;
+    if (attachFiles) {
+      const FileAgg = attachFiles.File;
+      if (!allQueryElements.includes(FileAgg)) allQueryElements.push(FileAgg);
+      if (!allMutationElements.includes(FileAgg))
+        allMutationElements.push(FileAgg);
+      attachmentsBridge = {
+        loadAttachments: async (ctx: any, fileIds: string[]) => {
+          const refs: any[] = [];
+          for (const fileId of fileIds) {
+            const rec = await ctx
+              .query(FileAgg)
+              .getById({ _id: fileId });
+            if (!rec) continue;
+            let providerFileIds: Record<string, string> = {};
+            if (typeof rec.providerFileIdsJson === "string") {
+              try {
+                const parsed = JSON.parse(rec.providerFileIdsJson);
+                if (parsed && typeof parsed === "object") providerFileIds = parsed;
+              } catch {}
+            }
+            refs.push({
+              fileId,
+              name: rec.name,
+              mime: rec.mime,
+              s3Key: rec.s3Key,
+              providerFileIds,
+            });
+          }
+          return refs;
+        },
+        bindProviderFileId: async (
+          ctx: any,
+          fileId: string,
+          provider: string,
+          providerFileId: string,
+        ) => {
+          await ctx
+            .mutate(FileAgg)
+            .bindProviderFileId({ _id: fileId, provider, providerFileId });
+        },
+      };
+    }
+
     const listenerConfig = {
       name,
       messageElement: Message,
@@ -333,6 +410,7 @@ export class ArcChat<const Data extends ArcChatData = DefaultChatData> {
       alias: aliasOverride ?? name,
       recordUsage: aiConfig.recordUsage,
       billTo: billTo ?? undefined,
+      attachments: attachmentsBridge,
     };
 
     const aiListener = createAiGenerationListener(listenerConfig);

package/src/listeners/ai-generation-listener.ts

@@ -1,8 +1,10 @@
 /// <reference path="../arc.d.ts" />
 import { listener, type ArcContextElement, type ArcFunction } from "@arcote.tech/arc";
 import type {
+  ArcFileRef,
   ArcToolAny,
   AssistantContentBlock,
+  BoundProviderFile,
   Conversation,
   ConversationTurn,
   LLMProvider,
@@ -59,6 +61,29 @@ export interface AiGenerationListenerConfig {
    * listener can treat the pair as always-present in the call site.
    */
   billTo?: (tokenParams: Record<string, any>) => string;
+  /**
+   * Wiązanie z fragmentem `arc-files` — wstrzykiwany przez chat-builder gdy
+   * consumer woła `.attachFiles({ File })`.
+   *
+   *  - `loadAttachments(fileIds)` — ładuje `ArcFile` records po fileId'ach
+   *    (dla `request.files`); zwracamy ArcFileRef z aktualnymi
+   *    `providerFileIds` z DB.
+   *  - `bindProviderFileId(fileId, provider, providerFileId)` — wywoływane
+   *    dla każdego `BoundProviderFile` zwróconego przez adapter (cache
+   *    lazy uploadu — przy następnej generacji pomijamy upload).
+   */
+  attachments?: {
+    loadAttachments(
+      ctx: any,
+      fileIds: string[],
+    ): Promise<ArcFileRef[]>;
+    bindProviderFileId(
+      ctx: any,
+      fileId: string,
+      provider: string,
+      providerFileId: string,
+    ): Promise<void>;
+  };
 }
 
 // ─── History reconstruction ─────────────────────────────────────
@@ -233,6 +258,11 @@ interface RunLoopConfig {
   recordUsage?: AiGenerationListenerConfig["recordUsage"];
   /** Token-params → scopeId mapper from chat-builder `.billTo(...)`. */
   billTo?: AiGenerationListenerConfig["billTo"];
+  /** Attachments bridge — see `AiGenerationListenerConfig.attachments`. */
+  attachments?: AiGenerationListenerConfig["attachments"];
+  /** ArcFile records dla attachmentów ostatniego user msg (resolved przed
+   *  generation start; reused per loop iteration). */
+  initialAttachments?: ArcFileRef[];
 }
 
 async function runGenerationLoop(config: RunLoopConfig) {
@@ -310,6 +340,13 @@ async function runGenerationLoop(config: RunLoopConfig) {
       // robi nic.
       startStream(currentTurnId!);
 
+      // Files lecą TYLKO w pierwszej iteracji. Provider z continuation
+      // (OpenAI Responses) trzyma context server-side; provider w full
+      // mode (Claude/Gemini) ignoruje files z warningiem — i tak nie
+      // ma sensu duplikować attachmentów w każdym tool_result roundzie.
+      const filesForRequest =
+        executionCount === 0 ? config.initialAttachments : undefined;
+
       const result = await provider.streamComplete(
         {
           model,
@@ -320,6 +357,9 @@ async function runGenerationLoop(config: RunLoopConfig) {
           // Skraca time-to-first-token dla gpt-5 / o-series — pomija reasoning
           // step. Adaptery bez wsparcia ignorują.
           reasoningEffort: "minimal",
+          ...(filesForRequest && filesForRequest.length > 0
+            ? { files: filesForRequest }
+            : {}),
         },
         (chunk) => {
           if (chunk.type === "text_delta" && chunk.textDelta) {
@@ -356,6 +396,32 @@ async function runGenerationLoop(config: RunLoopConfig) {
         },
       );
 
+      // Cache lazy-uploaded provider file IDs w ArcFile aggregate — żeby
+      // kolejne generacje (i odnowiona historia) pomijały re-upload.
+      if (
+        config.attachments &&
+        result.boundProviderFiles &&
+        result.boundProviderFiles.length > 0
+      ) {
+        for (const bound of result.boundProviderFiles) {
+          try {
+            await config.attachments.bindProviderFileId(
+              ctx,
+              bound.fileId,
+              bound.provider,
+              bound.providerFileId,
+            );
+          } catch (err) {
+            // Best-effort cache — failure tu nie psuje turn'u, tylko
+            // następny request uploadowi plik ponownie.
+            console.warn(
+              "[arc-chat] attachments.bindProviderFileId failed:",
+              err,
+            );
+          }
+        }
+      }
+
       // Append to local history so the next iteration sees this turn.
       const assistantTurn: ConversationTurn = {
         role: "assistant",
@@ -570,6 +636,14 @@ export function createAiGenerationListener(config: AiGenerationListenerConfig) {
       const newTurnsStartIdx = history.length;
       history.push({ role: "user", content: userContent });
 
+      // Załaduj ArcFile records dla attachmentów ostatniego user msg
+      // (jeśli consumer wired `attachments` bridge przez `.attachFiles({File})`).
+      const initialAttachments = await resolveAttachments(
+        ctx,
+        config.attachments,
+        (event.payload as { attachmentsJson?: string }).attachmentsJson,
+      );
+
       await runGenerationLoop({
         ctx,
         messageElement,
@@ -588,6 +662,8 @@ export function createAiGenerationListener(config: AiGenerationListenerConfig) {
         alias: config.alias,
         recordUsage: config.recordUsage,
         billTo: config.billTo,
+        attachments: config.attachments,
+        initialAttachments,
         preCreatedAssistantMessageId: (
           event.payload as { assistantMessageId?: string }
         ).assistantMessageId,
@@ -595,6 +671,36 @@ export function createAiGenerationListener(config: AiGenerationListenerConfig) {
     });
 }
 
+/**
+ * Parsuje `attachmentsJson` (string[] fileIds) i deleguje do
+ * `attachments.loadAttachments(...)`. Brak attachments bridge ALBO brak
+ * JSON ALBO pusta lista → zwraca undefined (request bez `files`).
+ */
+async function resolveAttachments(
+  ctx: any,
+  attachments: AiGenerationListenerConfig["attachments"],
+  attachmentsJson: string | undefined,
+): Promise<ArcFileRef[] | undefined> {
+  if (!attachments || !attachmentsJson) return undefined;
+  let fileIds: string[] = [];
+  try {
+    const parsed = JSON.parse(attachmentsJson);
+    if (Array.isArray(parsed)) {
+      fileIds = parsed.filter((x): x is string => typeof x === "string");
+    }
+  } catch {
+    return undefined;
+  }
+  if (fileIds.length === 0) return undefined;
+  try {
+    const refs = await attachments.loadAttachments(ctx, fileIds);
+    return refs.length > 0 ? refs : undefined;
+  } catch (err) {
+    console.warn("[arc-chat] attachments.loadAttachments failed:", err);
+    return undefined;
+  }
+}
+
 // ─── Listener B: userResponded → AI resume ──────────────────────
 
 export function createAiResumeListener(config: AiGenerationListenerConfig) {
@@ -671,6 +777,7 @@ export function createAiResumeListener(config: AiGenerationListenerConfig) {
         alias: config.alias,
         recordUsage: config.recordUsage,
         billTo: config.billTo,
+        attachments: config.attachments,
         preCreatedAssistantMessageId: (
           event.payload as { assistantMessageId?: string }
         ).assistantMessageId,

package/src/react/chat-component.tsx

@@ -622,6 +622,9 @@ export function createChatComponent(
             scopeId,
             content,
             model: options.model,
+            ...(options.attachments && options.attachments.length > 0
+              ? { attachmentsJson: JSON.stringify(options.attachments) }
+              : {}),
           });
           // Reszta dzieje się przez auto-subscribe effect powyżej: mutacja
           // emit'uje `assistantTurnStarted` → DB query pushuje fresh assistant