@flamingo-stack/openframe-frontend-core 0.0.444 → 0.0.445

package/src/components/chat/hooks/use-nats-dialog-subscription.ts

@@ -182,7 +182,13 @@ export function useNatsDialogSubscription({
     }
   }, [enabled, wsUrl])
 
+  // Key the subscription effects on the topics CONTENT, not the array
+  // identity — hosts often pass an inline array, and an identity dep made
+  // every render tear down + recreate the subscriptions (plain NATS delivers
+  // nothing during that gap, so chunks were silently lost).
   const topicsKey = topics.join(',')
+  const topicsRef = useRef(topics)
+  topicsRef.current = topics
   const lastSubscribedDialogIdRef = useRef<string | null>(null)
   const isConnectedRef = useRef(isConnected)
   
@@ -260,7 +266,7 @@ export function useNatsDialogSubscription({
         }
       }
       
-      topics.forEach((topic) => {
+      topicsRef.current.forEach((topic) => {
         const subscription = client.subscribeBytes(
           `chat.${dialogId}.${topic}`,
           handleMessage(topic),
@@ -268,7 +274,7 @@ export function useNatsDialogSubscription({
         )
         subscriptionRefs.current.set(topic, subscription)
       })
-      
+
       lastSubscribedDialogIdRef.current = dialogId
       setIsSubscribed(true)
       onSubscribedRef.current?.()
@@ -292,7 +298,7 @@ export function useNatsDialogSubscription({
       lastSubscribedDialogIdRef.current = null
       abortControllerRef.current = null
     }
-  }, [enabled, dialogId, topicsKey, topics])
+  }, [enabled, dialogId, topicsKey])
 
   useEffect(() => {
     if (!enabled || !currentDialogIdRef.current || !isConnected) {
@@ -322,7 +328,7 @@ export function useNatsDialogSubscription({
         }
       }
       
-      topics.forEach((topic) => {
+      topicsRef.current.forEach((topic) => {
         const subscription = client.subscribeBytes(
           `chat.${dialogId}.${topic}`,
           handleMessage(topic),
@@ -330,14 +336,14 @@ export function useNatsDialogSubscription({
         )
         subscriptionRefs.current.set(topic, subscription)
       })
-      
+
       lastSubscribedDialogIdRef.current = dialogId
       setIsSubscribed(true)
       onSubscribedRef.current?.()
     } else if (subscriptionRefs.current.size > 0) {
       setIsSubscribed(true)
     }
-  }, [isConnected, enabled, topics, topicsKey])
+  }, [isConnected, enabled, topicsKey])
 
   return { isConnected, isSubscribed, reconnectionCount }
 }

package/src/components/chat/hooks/use-realtime-chunk-processor.ts

@@ -193,6 +193,16 @@ export function useRealtimeChunkProcessor(
           // is the source of truth. Don't fire onToolExecuted here — its
           // cross-message scan is first-match-wins and could touch a
           // same-execId segment in a prior bubble (agent retry case).
+          //
+          // KNOWN EDGE (accepted): a slow async batch tool whose EXECUTED
+          // lands only AFTER the continuation stream's MESSAGE_START takes
+          // this path too — the freshly reset accumulator has no batch
+          // segment to merge into, so the chunk renders as a standalone card
+          // in the new bubble while the prior batch card's executions slot
+          // stays 'executing' until the next history refetch. Routing such
+          // chunks cross-message would reintroduce the retry hazard above;
+          // revisit only if the backend confirms batch executions can
+          // overlap the continuation stream.
           const segments = accumulator.addToolExecution(action.segment)
           emitSegments(segments)
           break
@@ -286,6 +296,26 @@ export function useRealtimeChunkProcessor(
               approvalType: escalatedData.approvalType,
             })
 
+            // The escalated card was never displayed inline, so this emit is
+            // what surfaces it after resolution. In-stream the cumulative
+            // array is correct; post-MESSAGE_END the accumulator was RESET,
+            // so a cumulative (replace-mode) emit would wipe the trailing
+            // bubble down to the lone card — emit only the resolved card(s)
+            // as an append instead. Store hosts upsert batches by request id,
+            // so a replayed append stays idempotent.
+            const emitResolved = (segments: MessageSegment[]) => {
+              if (isInStreamRef.current) {
+                emitSegments(segments)
+                return
+              }
+              const delta = segments.filter(
+                (s) =>
+                  (s.type === 'approval_request' && s.data.requestId === requestId) ||
+                  (s.type === 'approval_batch' && s.data.approvalRequestId === requestId),
+              )
+              emitSegments(delta, { append: true })
+            }
+
             if (escalatedData.toolCalls && escalatedData.toolCalls.length > 0) {
               if (batchApprovalsEnabled) {
                 const segments = accumulator.addApprovalBatch(
@@ -296,7 +326,7 @@ export function useRealtimeChunkProcessor(
                   undefined,
                   resolvedByName,
                 )
-                emitSegments(segments)
+                emitResolved(segments)
               } else {
                 let segments = accumulator.getSegments()
                 for (const call of escalatedData.toolCalls) {
@@ -309,7 +339,7 @@ export function useRealtimeChunkProcessor(
                     status,
                   )
                 }
-                emitSegments(segments)
+                emitResolved(segments)
               }
             } else {
               const segments = accumulator.addApprovalRequest(
@@ -319,7 +349,7 @@ export function useRealtimeChunkProcessor(
                 escalatedData.approvalType,
                 status,
               )
-              emitSegments(segments)
+              emitResolved(segments)
             }
           } else {
             // Always keep the in-memory accumulator in sync so a following
@@ -419,6 +449,13 @@ export function useRealtimeChunkProcessor(
     hasInitializedWithData.current = false
     sawDirectMessageRef.current = false
     directTeardownFiredRef.current = false
+    // Stream-state flags are per-dialog too. Leaking them across a reset
+    // made the next dialog's cold-start chunks take the post-stream append
+    // path (hasEverStreamed stuck true) — which consumers may silently drop
+    // when no assistant bubble exists yet — and left tool/compaction routing
+    // thinking a stream was still open (isInStream stuck true).
+    isInStreamRef.current = false
+    hasEverStreamedRef.current = false
   }, [])
 
   const updateApprovalStatus = useCallback(

package/src/components/chat/utils/__tests__/process-historical-messages-approvals.test.ts

@@ -0,0 +1,62 @@
+/**
+ * Regression guard for `displayApprovalTypes` semantics in the history
+ * processors. An OMITTED option must render EVERY approval type inline —
+ * consumers (tickets/mingo admin surfaces) that pass a wider list to their
+ * realtime processor but omit it on the history path relied on this, and a
+ * silent `['CLIENT']` default made their pending ADMIN approval cards vanish
+ * on every reload/reconnect refetch. Parity with realtime is opt-in via an
+ * explicit list.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { processHistoricalMessagesWithErrors } from '../process-historical-messages'
+import type { HistoricalMessage, MessageSegment } from '../../types'
+
+const adminApprovalMessage = (id: string): HistoricalMessage => ({
+  id,
+  createdAt: '2026-07-17T12:00:00Z',
+  owner: { type: 'ASSISTANT' },
+  messageData: [
+    {
+      type: 'APPROVAL_REQUEST',
+      approvalRequestId: `req-${id}`,
+      approvalType: 'ADMIN',
+      command: 'systemctl restart nats',
+    },
+  ],
+})
+
+const approvalSegments = (segments: MessageSegment[] | string | undefined) =>
+  Array.isArray(segments)
+    ? segments.filter((s) => s.type === 'approval_request' || s.type === 'approval_batch')
+    : []
+
+describe('processHistoricalMessagesWithErrors — displayApprovalTypes', () => {
+  it('renders non-CLIENT approvals inline when the option is OMITTED', () => {
+    const { messages, escalatedApprovals } = processHistoricalMessagesWithErrors([
+      adminApprovalMessage('m1'),
+    ])
+    const rendered = messages.flatMap((m) => approvalSegments(m.content))
+    expect(rendered).toHaveLength(1)
+    expect(escalatedApprovals.size).toBe(0)
+  })
+
+  it('escalates (does not render) approval types excluded by an explicit list', () => {
+    const { messages, escalatedApprovals } = processHistoricalMessagesWithErrors(
+      [adminApprovalMessage('m1')],
+      { displayApprovalTypes: ['CLIENT'] },
+    )
+    const rendered = messages.flatMap((m) => approvalSegments(m.content))
+    expect(rendered).toHaveLength(0)
+    expect(escalatedApprovals.has('req-m1')).toBe(true)
+  })
+
+  it('renders approval types included by an explicit list', () => {
+    const { messages } = processHistoricalMessagesWithErrors(
+      [adminApprovalMessage('m1')],
+      { displayApprovalTypes: ['CLIENT', 'ADMIN'] },
+    )
+    const rendered = messages.flatMap((m) => approvalSegments(m.content))
+    expect(rendered).toHaveLength(1)
+  })
+})

package/src/components/chat/utils/message-segment-accumulator.ts

@@ -225,6 +225,12 @@ export class MessageSegmentAccumulator {
       if (!hasCall) return seg
 
       const prev: ApprovalBatchExecutionState | undefined = seg.data.executions?.[execId]
+      // Never downgrade a done slot back to executing (redelivered EXECUTING
+      // after its EXECUTED already landed) — matched, but unchanged.
+      if (toolData.type === 'EXECUTING_TOOL' && prev?.status === 'done') {
+        matched = true
+        return seg
+      }
       const next: ApprovalBatchExecutionState =
         toolData.type === 'EXECUTED_TOOL'
           ? { status: 'done', result: toolData.result, success: toolData.success }

package/src/components/chat/utils/process-historical-messages.ts

@@ -78,7 +78,15 @@ export function processHistoricalMessages(
     onReject,
     chatTypeFilter,
     approvalStatuses = {},
+    // An omitted option means "display every approval type" — the original
+    // history semantics. Deliberately NOT defaulted to the realtime
+    // processor's ['CLIENT']: consumers that pass a wider list to their
+    // realtime processor but omit it on the history path would silently lose
+    // pending non-CLIENT approval cards on every reload/reconnect refetch
+    // (they also ignore `escalatedApprovals`). Realtime/history parity is
+    // opt-in: pass the same explicit list to both.
     displayApprovalTypes,
+    batchApprovalsEnabled,
   } = options
 
   const processedMessages: ProcessedMessage[] = []
@@ -174,7 +182,13 @@ export function processHistoricalMessages(
       lastAssistantId = msg.id
 
       messageDataArray.forEach((data) => {
-        processMessageData(data, accumulator, approvalStatuses, { displayApprovalTypes }, escalatedApprovals)
+        processMessageData(
+          data,
+          accumulator,
+          approvalStatuses,
+          { displayApprovalTypes, batchApprovalsEnabled },
+          escalatedApprovals,
+        )
       })
 
       // Check if we should flush (next message is from user or last message)
@@ -473,7 +487,9 @@ export function processHistoricalMessagesWithErrors(
   messages: HistoricalMessage[],
   options: MessageProcessingOptions = {}
 ): ProcessHistoricalMessagesResult {
-  const { chatTypeFilter, assistantName = 'Fae', assistantType = 'fae', assistantAvatar, onApprove, onReject, approvalStatuses = {}, displayApprovalTypes } = options
+  // displayApprovalTypes omitted = display every approval type (original
+  // history semantics — see the matching note in processHistoricalMessages).
+  const { chatTypeFilter, assistantName = 'Fae', assistantType = 'fae', assistantAvatar, onApprove, onReject, approvalStatuses = {}, displayApprovalTypes, batchApprovalsEnabled } = options
 
   const processedMessages: ProcessedMessage[] = []
   const accumulator = createMessageSegmentAccumulator({ onApprove, onReject })
@@ -563,7 +579,13 @@ export function processHistoricalMessagesWithErrors(
       lastAssistantId = msg.id
 
       messageDataArray.forEach((data) => {
-        processMessageData(data, accumulator, approvalStatuses, { displayApprovalTypes }, escalatedApprovals)
+        processMessageData(
+          data,
+          accumulator,
+          approvalStatuses,
+          { displayApprovalTypes, batchApprovalsEnabled },
+          escalatedApprovals,
+        )
       })
 
       const nextMsg = messages[index + 1]

package/src/nats/shared-connection.ts

@@ -52,21 +52,30 @@ export interface ReleaseClientOptions {
   delayMs?: number
 }
 
-let shared: SharedConnection | null = null
-
+// One shared connection PER URL. The previous single-slot implementation
+// force-closed whatever was connected the moment any consumer acquired a
+// DIFFERENT URL — even with live refs on it. With two chat surfaces on
+// distinct endpoints (`/ws/nats` client chat vs `/ws/nats-api` dashboard)
+// mounted at once, each acquire killed the other's socket, and the loser's
+// retry loop self-cancelled (connection identity mismatch) leaving a dead
+// subscription that silently received nothing.
+const connections = new Map<string, SharedConnection>()
+
+/** Legacy accessor from the single-slot era: returns the first live shared
+ *  connection, or null. With MULTIPLE URLs connected (e.g. `/ws/nats` client
+ *  chat + `/ws/nats-api` dashboard mounted together) "first" is whichever
+ *  surface acquired first — an arbitrary, mount-order-dependent answer.
+ *  Prefer `getSharedConnectionFor(url)`; this stays only for external
+ *  registry-pinned consumers of the old single-connection API. */
 export function getSharedConnection(): SharedConnection | null {
-  return shared
+  const first = connections.values().next()
+  return first.done ? null : first.value
 }
 
 export function acquireClient(url: string, opts?: AcquireClientOptions): SharedConnection {
-  if (shared?.wsUrl !== url) {
-    if (shared) {
-      if (shared.closeTimer) clearTimeout(shared.closeTimer)
-      const old = shared
-      shared = null
-      void old.client.close().catch(() => {})
-    }
+  let conn = connections.get(url)
 
+  if (!conn) {
     const {
       name = 'openframe-frontend',
       user = 'machine',
@@ -87,7 +96,7 @@ export function acquireClient(url: string, opts?: AcquireClientOptions): SharedC
       maxPingOut,
     })
 
-    shared = {
+    conn = {
       wsUrl: url,
       client,
       connectPromise: null,
@@ -96,39 +105,43 @@ export function acquireClient(url: string, opts?: AcquireClientOptions): SharedC
       retryTimer: null,
       retryOwner: null,
     }
+    connections.set(url, conn)
   }
 
-  shared.refCount += 1
-  if (shared.closeTimer) {
-    clearTimeout(shared.closeTimer)
-    shared.closeTimer = null
+  conn.refCount += 1
+  if (conn.closeTimer) {
+    clearTimeout(conn.closeTimer)
+    conn.closeTimer = null
   }
-  return shared
+  return conn
 }
 
 export function releaseClient(url: string, opts?: ReleaseClientOptions): void {
-  if (!shared || shared.wsUrl !== url) return
+  const conn = connections.get(url)
+  if (!conn) return
 
-  shared.refCount = Math.max(0, shared.refCount - 1)
-  if (shared.refCount > 0) return
+  conn.refCount = Math.max(0, conn.refCount - 1)
+  if (conn.refCount > 0) return
 
   const delay = opts?.delayMs ?? NATS_DEFAULTS.SHARED_CLOSE_DELAY_MS
-  shared.closeTimer = setTimeout(() => {
-    const s = shared
-    shared = null
-    if (s) {
-      if (s.retryTimer) {
-        clearTimeout(s.retryTimer)
-        s.retryTimer = null
-      }
-      void s.client.close().catch(() => {})
+  conn.closeTimer = setTimeout(() => {
+    conn.closeTimer = null
+    // A new acquire may have raced in during the grace period.
+    if (conn.refCount > 0) return
+    if (connections.get(url) === conn) {
+      connections.delete(url)
+    }
+    if (conn.retryTimer) {
+      clearTimeout(conn.retryTimer)
+      conn.retryTimer = null
     }
+    void conn.client.close().catch(() => {})
   }, delay)
 }
 
 export function getSharedConnectionFor(url: string | null | undefined): SharedConnection | null {
   if (!url) return null
-  return shared && shared.wsUrl === url ? shared : null
+  return connections.get(url) ?? null
 }
 
 // ---------------------------------------------------------------------------