@arcote.tech/arc-chat 0.7.17 → 0.7.19

package/package.json

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

package/src/react/chat-component.tsx

@@ -9,6 +9,33 @@ import type {
 import { Chat, ChatMessage, ChatInputProvider, ChatLabelsProvider, ChatToolLog, useChatLabels } from "@arcote.tech/arc-ds";
 import { VoiceTextarea } from "@arcote.tech/arc-ai-voice";
 
+// ─── Debug / instrumentation ─────────────────────────────────────────────
+// Production-only chat hang: SSE `isStreaming` and DB `isGenerating` can
+// desync (separate channels, prod latency). We log when the reconcile
+// watchdog has to force-close a turn the DB already finished. Kept dependency-
+// free (no OTel import — this fragment is src-only and bundles into any app):
+// the host app can pipe these to its telemetry via `globalThis.__arcChatOnStuck`.
+function reportReconcileStuck(attrs: Record<string, unknown>): void {
+  // eslint-disable-next-line no-console
+  console.warn("[arc-chat][reconcile_stuck]", attrs);
+  try {
+    (globalThis as any).__arcChatOnStuck?.(attrs);
+  } catch {
+    /* reporter must never break the chat */
+  }
+}
+
+/** Verbose per-message timing, gated behind `globalThis.__ARC_CHAT_DEBUG`.
+ *  Used to see the SSE-vs-DB channel skew (who arrives first, delta-t). */
+function chatDebug(...args: unknown[]): void {
+  if ((globalThis as any).__ARC_CHAT_DEBUG) {
+    const ts =
+      typeof performance !== "undefined" ? performance.now().toFixed(0) : "";
+    // eslint-disable-next-line no-console
+    console.debug(`[arc-chat +${ts}ms]`, ...args);
+  }
+}
+
 interface ChatComponentConfig {
   chatName: string;
   tools: ArcToolAny[];
@@ -85,6 +112,18 @@ export function createChatComponent(
     /** Set messageIds dla których SSE zwrócił 410 (server restart mid-stream).
      *  Renderowane jako TimelineItem "interrupted" z retry button. */
     const [interruptedIds, setInterruptedIds] = useState<Set<string>>(() => new Set());
+    /** Bumped by the reconcile watchdog to FORCE a timeline rebuild even when
+     *  `historySig` already changed (during streaming) and won't change again.
+     *  See the watchdog effect below. */
+    const [reconcileNonce, setReconcileNonce] = useState(0);
+    /** AbortController of the currently-open SSE stream, exposed via ref so the
+     *  watchdog can tear it down when the DB says the turn is already done. */
+    const sseCtrlRef = useRef<AbortController | null>(null);
+    /** Last SSE event type seen (for stuck telemetry — was `done` ever sent?). */
+    const lastSseEventRef = useRef<string | null>(null);
+    /** When the (isStreaming=true ∧ DB-idle) divergence first appeared — for
+     *  the debounce window and the `waitedMs` stuck attribute. */
+    const stuckSinceRef = useRef<number | null>(null);
 
     const queries = scope.useQuery();
     const mutations = scope.useMutation();
@@ -243,16 +282,111 @@ export function createChatComponent(
       }
 
       setTimeline(items);
-      // Dep TYLKO `historySig` + `interruptedIds`. Bez `isStreaming` — gdyby
-      // było w deps: po `done` SSE flips isStreaming=false → useEffect refires →
-      // może zobaczyć STAREJ `isGenerating:1` row (DB jeszcze nie zaprojektowała
-      // assistantTurnCompleted) → reset do streaming mode → caret nigdy nie znika.
-    }, [historySig, interruptedIds]);
+      // Deps: `historySig` + `interruptedIds` + `reconcileNonce`. Wciąż BEZ
+      // `isStreaming` — gdyby było w deps: po `done` SSE flips isStreaming=false →
+      // refire → może zobaczyć STARĄ `isGenerating:1` (DB jeszcze nie
+      // zaprojektowała assistantTurnCompleted) → reset do streaming → caret nie
+      // znika. `reconcileNonce` (bumpowany przez watchdog) wymusza rebuild w
+      // odwrotnym race (query-update wyprzedził SSE `done` → historySig zmienił
+      // się PODCZAS isStreaming=true → rebuild pominięty guardem i bez nonce
+      // nigdy nie nadrobiony → produkcyjny hang).
+    }, [historySig, interruptedIds, reconcileNonce]);
+
+    // Verbose DB-side timing (gated) — paired with the SSE-event logs above,
+    // this shows the channel skew: who arrives first, and how far apart.
+    useEffect(() => {
+      chatDebug("db update", {
+        count: historyLen,
+        activeGenerating: activeGeneratingMessageId,
+      });
+    }, [historySig, historyLen, activeGeneratingMessageId]);
+
+    // ─── Reconcile watchdog — DB is the arbiter of "is a turn running" ──
+    // Production hang: SSE `done` and the DB `assistantTurnCompleted` projection
+    // travel on separate channels (SSE vs WS query sync). When the query-update
+    // (`isGenerating→false`) wins the race while `isStreaming` is still true — or
+    // when `done` is lost entirely (410 exhaustion / server restart) — the
+    // rebuild guard skips and never retries, so the chat sticks in a streaming
+    // state until a page refresh.
+    //
+    // DB truth: `activeGeneratingMessageId === null` ⇒ no turn is generating. If
+    // we still believe we're streaming after a short debounce, force-close the
+    // turn: abort the (dead) SSE, drop `isStreaming`, and bump `reconcileNonce`
+    // so the rebuild runs with the final DB blocks. The debounce avoids
+    // flicker in the brief between-turns window (old turn done, next not started
+    // yet). No false fires during a real stream — the DB then holds
+    // `isGenerating:1`, so `activeGeneratingMessageId` is non-null.
+    useEffect(() => {
+      if (!(isStreaming && activeGeneratingMessageId === null)) {
+        stuckSinceRef.current = null;
+        return;
+      }
+      if (stuckSinceRef.current === null) stuckSinceRef.current = Date.now();
+      const since = stuckSinceRef.current;
+      const RECONCILE_DEBOUNCE_MS = 200;
+      const timer = setTimeout(() => {
+        reportReconcileStuck({
+          scopeId,
+          chatName,
+          lastSseEvent: lastSseEventRef.current,
+          waitedMs: Date.now() - since,
+        });
+        sseCtrlRef.current?.abort();
+        sseCtrlRef.current = null;
+        stuckSinceRef.current = null;
+        setIsStreaming(false);
+        setReconcileNonce((n) => n + 1);
+      }, RECONCILE_DEBOUNCE_MS);
+      return () => clearTimeout(timer);
+    }, [isStreaming, activeGeneratingMessageId, scopeId]);
+
+    // ─── Backstop: merge interactive-tool answers regardless of isStreaming ──
+    // Answering an interactive tool (askQuestions) creates a `tool_result` row
+    // AND starts a new assistant turn — so `isStreaming` flips back to true and
+    // the global rebuild guard freezes the whole timeline. Without this, the
+    // answered question stays in input-view ("Odpowiedz na pytania" + the
+    // questions) instead of the answer-view, until that next turn ends — and on
+    // prod its SSE `done` is often lost (the turn finalizes after the DB
+    // projection that nulls `activeGeneratingMessageId` aborts the stream), so
+    // it never catches up. This flips any `calling` tool block to answer-view
+    // the moment its `tool_result` lands in the DB, bypassing the guard.
+    useEffect(() => {
+      if (!historyData) return;
+      const resultMap = new Map<string, { content: string; isError?: boolean }>();
+      for (const msg of historyData) {
+        if (msg.role === "tool_result" && msg.toolCallId) {
+          resultMap.set(msg.toolCallId, {
+            content: msg.content,
+            isError: msg.isError,
+          });
+        }
+      }
+      if (resultMap.size === 0) return;
+      setTimeline((prev) => {
+        let changed = false;
+        const next = prev.map((t) => {
+          if (t.type !== "tool" || !t.calling) return t;
+          const r = resultMap.get(t.toolCallId);
+          if (!r) return t;
+          changed = true;
+          return {
+            ...t,
+            calling: false,
+            status: (r.isError ? "error" : "complete") as ToolStatus,
+            result: tryParseJson(r.content),
+            error: r.isError ? r.content : undefined,
+          };
+        });
+        return changed ? next : prev;
+      });
+    }, [historySig]);
 
     // ─── SSE event processing ───────────────────────────────────
     const processEventRef = useRef<((event: ChatStreamEvent) => void) | null>(null);
     const processEvent = useCallback(
       (event: ChatStreamEvent) => {
+        lastSseEventRef.current = event.type;
+        chatDebug("sse event", event.type);
         switch (event.type) {
           case "init": {
             // Pierwszy event po `subscribe(messageId)`. Niesie snapshot
@@ -549,8 +683,11 @@ export function createChatComponent(
       if (!activeGeneratingMessageId) return;
       const messageId = activeGeneratingMessageId;
       const ctrl = new AbortController();
+      sseCtrlRef.current = ctrl;
+      lastSseEventRef.current = null;
       let cancelled = false;
       setIsStreaming(true);
+      chatDebug("sse open", { messageId });
 
       (async () => {
         try {
@@ -613,6 +750,7 @@ export function createChatComponent(
       return () => {
         cancelled = true;
         ctrl.abort();
+        if (sseCtrlRef.current === ctrl) sseCtrlRef.current = null;
       };
     }, [activeGeneratingMessageId]);