@arcote.tech/arc-chat 0.7.13 → 0.7.15

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc-chat",
   "type": "module",
-  "version": "0.7.13",
+  "version": "0.7.15",
   "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.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",
+    "@arcote.tech/arc": "^0.7.15",
+    "@arcote.tech/arc-ai": "^0.7.15",
+    "@arcote.tech/arc-ai-voice": "^0.7.15",
+    "@arcote.tech/arc-auth": "^0.7.15",
+    "@arcote.tech/arc-ds": "^0.7.15",
+    "@arcote.tech/platform": "^0.7.15",
     "lucide-react": ">=0.400.0",
     "react": ">=18.0.0",
     "typescript": "^5.0.0"

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

@@ -625,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 });
@@ -733,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 });
@@ -830,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}`);
 

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);