@arcote.tech/arc-chat 0.7.12 → 0.7.14

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc-chat",
   "type": "module",
-  "version": "0.7.12",
+  "version": "0.7.14",
   "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.14",
+    "@arcote.tech/arc-ai": "^0.7.14",
+    "@arcote.tech/arc-ai-voice": "^0.7.14",
+    "@arcote.tech/arc-auth": "^0.7.14",
+    "@arcote.tech/arc-ds": "^0.7.14",
+    "@arcote.tech/platform": "^0.7.14",
     "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",
@@ -559,6 +625,18 @@ export function createAiGenerationListener(config: AiGenerationListenerConfig) {
       const provider = resolveProvider(model, scopeId);
       if (!provider) return;
 
+      // Otwórz in-memory stream PRZED pierwszym awaitem (getByScope niżej +
+      // buildInstructions w pętli). Async listenery w arc startują
+      // synchronicznie w trakcie emit i suspendują na 1. await, więc wpis
+      // powstaje ZANIM mutacja zwróci → klient subskrybujący zaraz po mutacji
+      // nie wyprzedzi startStream (to był główny powód 410 ~1/5, szczególnie
+      // dla stage'ów z wolnym buildInstructions). Idempotent; runGenerationLoop
+      // woła ponownie dla iteracji 2+ (multi-turn).
+      const preAssistantId = (
+        event.payload as { assistantMessageId?: string }
+      ).assistantMessageId;
+      if (preAssistantId) startStream(preAssistantId);
+
       const dbMessages = await ctx
         .query(messageElement)
         .getByScope({ scopeId });
@@ -570,6 +648,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 +674,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 +683,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) {
@@ -627,6 +745,14 @@ export function createAiResumeListener(config: AiGenerationListenerConfig) {
     .handle(async (ctx, event) => {
       const { sessionId, scopeId, toolCallId } = event.payload;
 
+      // Otwórz in-memory stream przed 1. awaitem — patrz listener generation.
+      // (provider sprawdzany niżej po await; rzadki misconfig sprząta
+      // MAX_STREAM_MS w stream-registry.)
+      const preAssistantId = (
+        event.payload as { assistantMessageId?: string }
+      ).assistantMessageId;
+      if (preAssistantId) startStream(preAssistantId);
+
       const dbMessages = await ctx
         .query(messageElement)
         .getByScope({ scopeId });
@@ -671,6 +797,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,
@@ -723,6 +850,9 @@ export function createAiRetryListener(config: AiGenerationListenerConfig) {
         model: modelName,
       } = event.payload as any;
 
+      // Otwórz in-memory stream przed 1. awaitem — patrz listener generation.
+      if (assistantMsgId) startStream(assistantMsgId);
+
       const dbMessages = await ctx
         .query(messageElement)
         .getByScope({ scopeId });

package/src/react/chat-component.tsx

@@ -554,21 +554,30 @@ export function createChatComponent(
 
       (async () => {
         try {
-          const res = await fetch(
-            `/route/chat/${chatName}/stream/${messageId}`,
-            {
+          // 410 = brak in-memory streamu dla messageId. Serwer tworzy stream
+          // synchronicznie ze startem turnu (listener przed 1. awaitem), więc
+          // race "GET przed startStream" jest zamknięty — ale zostaje krótki
+          // residualny race i okno restartu serwera. Ponów kilka razy z
+          // backoffem zanim uznasz turn za przerwany: startStream / grace
+          // window zwykle dogania w tym czasie.
+          let res: Response | null = null;
+          const MAX_410_RETRIES = 4;
+          const RETRY_DELAY_MS = 300;
+          for (let attempt = 0; ; attempt++) {
+            res = await fetch(`/route/chat/${chatName}/stream/${messageId}`, {
               credentials: "include",
               signal: ctrl.signal,
               headers: { Accept: "text/event-stream" },
-            },
-          );
-          if (res.status === 410) {
-            // Stream nie istnieje — proces zrestartował się mid-stream
-            // (in-memory state utracony). Mark messageId jako interrupted,
-            // klient pokaże retry UI.
-            setInterruptedIds((prev) => new Set(prev).add(messageId));
-            setIsStreaming(false);
-            return;
+            });
+            if (res.status !== 410) break;
+            if (attempt >= MAX_410_RETRIES) {
+              // Naprawdę nieosiągalny (restart mid-stream / poza grace window).
+              setInterruptedIds((prev) => new Set(prev).add(messageId));
+              setIsStreaming(false);
+              return;
+            }
+            await new Promise<void>((r) => setTimeout(r, RETRY_DELAY_MS));
+            if (cancelled) return;
           }
           if (!res.ok) throw new Error(`Stream failed: ${res.status}`);
 
@@ -622,6 +631,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

package/src/streaming/stream-registry.ts

@@ -33,6 +33,13 @@ interface MessageStream {
   >;
   subscribers: Set<ReadableStreamDefaultController<Uint8Array>>;
   keepAliveInterval?: ReturnType<typeof setInterval>;
+  /**
+   * Hard safety cap. `startStream` schedules it; `finalize` clears it. If a
+   * generation never calls `finalize()` (listener threw before the loop, no
+   * provider, hung stream) this evicts the entry so the registry can't grow
+   * unbounded — the only TTL on a *live* (non-finalized) stream.
+   */
+  maxLifetimeTimer?: ReturnType<typeof setTimeout>;
   finalized: boolean;
   finalEvent?: ChatStreamEvent;
 }
@@ -40,6 +47,9 @@ interface MessageStream {
 const streams = new Map<string, MessageStream>();
 const FINALIZE_GRACE_MS = 5_000;
 const KEEPALIVE_INTERVAL_MS = 5_000;
+// Generous upper bound for a single turn's stream (one LLM response, even with
+// tools). Far longer than any realistic generation; only trips on a leak.
+const MAX_STREAM_MS = 10 * 60_000;
 const encoder = new TextEncoder();
 
 function encode(event: ChatStreamEvent): Uint8Array {
@@ -75,13 +85,40 @@ function ensureKeepAlive(s: MessageStream): void {
  */
 export function startStream(messageId: string): void {
   if (streams.has(messageId)) return;
-  streams.set(messageId, {
+  const s: MessageStream = {
     messageId,
     currentBlocks: [],
     toolCallsById: new Map(),
     subscribers: new Set(),
     finalized: false,
-  });
+  };
+  // Leak guard — see MAX_STREAM_MS. Cleared in finalize() on the normal path.
+  s.maxLifetimeTimer = setTimeout(() => evict(messageId), MAX_STREAM_MS);
+  streams.set(messageId, s);
+}
+
+/**
+ * Force-drop a stream that never finalized (safety net). Closes any subscribers
+ * and tears down timers. No-op if already gone.
+ */
+function evict(messageId: string): void {
+  const s = streams.get(messageId);
+  if (!s) return;
+  if (s.keepAliveInterval) {
+    clearInterval(s.keepAliveInterval);
+    s.keepAliveInterval = undefined;
+  }
+  if (s.maxLifetimeTimer) {
+    clearTimeout(s.maxLifetimeTimer);
+    s.maxLifetimeTimer = undefined;
+  }
+  for (const ctrl of s.subscribers) {
+    try {
+      ctrl.close();
+    } catch {}
+  }
+  s.subscribers.clear();
+  streams.delete(messageId);
 }
 
 /**
@@ -266,6 +303,12 @@ export function finalize(
     clearInterval(s.keepAliveInterval);
     s.keepAliveInterval = undefined;
   }
+  // Normal teardown owns the lifecycle now — cancel the safety cap so it can't
+  // fire during/after the grace window.
+  if (s.maxLifetimeTimer) {
+    clearTimeout(s.maxLifetimeTimer);
+    s.maxLifetimeTimer = undefined;
+  }
 
   setTimeout(() => {
     streams.delete(messageId);