@flamingo-stack/openframe-frontend-core 0.0.288 → 0.0.289-snapshot.20260618174139

package/src/components/chat/entity-cards/dispatch.tsx

@@ -74,6 +74,7 @@ import { MingoIcon } from '../../icons'
 import { EyeIcon } from '../../icons-v2-generated/interface/eye-icon'
 import { ArrowRightUpIcon } from '../../icons-v2-generated/arrows/arrow-right-up-icon'
 import { TagIcon } from '../../icons-v2-generated/shopping/tag-icon'
+import { QuestionCircleIcon } from '../../icons-v2-generated/signs-and-symbols/question-circle-icon'
 import { SlackLogoGreyIcon } from '../../icons-v2-generated/brand-logos/slack-logo-grey-icon'
 import { FileContentIcon } from '../../icons-v2-generated/documents/file-content-icon'
 import { ChartBar01VerIcon } from '../../icons-v2-generated/charts/chart-bar-01-ver-icon'
@@ -354,6 +355,39 @@ function HubspotTicketChatCard({
   )
 }
 
+/** FAQ Q&A — title=question, body=answer preview, optional section pill.
+ *  No-fetch card: every field the renderer needs already lives on the
+ *  ChatRef (hub's `FAQ_MAPPER.toRetrievedDoc` populates `title` /
+ *  `preview` / `url` / `targetPlatform`, and the section name is threaded
+ *  through `metadata.section` for the badge). The card itself stays pure
+ *  presentation — same shape as `SlackChatCard` / `HubspotTicketChatCard`. */
+function FaqChatCard({
+  chatRef,
+  isNewTab,
+  discuss,
+}: {
+  chatRef: ChatRef
+  isNewTab: boolean
+  discuss?: CardDiscussAction
+}) {
+  const section =
+    typeof chatRef.metadata?.section === 'string'
+      ? (chatRef.metadata.section as string).trim()
+      : undefined
+  const statusLabel = section && section.length > 0 ? section : 'FAQ'
+  return (
+    <MingoInfoCard
+      title={chatRef.title}
+      description={chatRef.preview ?? undefined}
+      icon={<QuestionCircleIcon size={24} />}
+      status={{ label: statusLabel, variant: 'grey' }}
+      anchorProps={buildAnchorProps(chatRef.url, isNewTab)}
+      menuGroups={cardMenuGroups(chatRef.url, discuss)}
+      menuAriaLabel="FAQ actions"
+    />
+  )
+}
+
 function SlackChatCard({
   chatRef,
   isNewTab,
@@ -1121,6 +1155,14 @@ const CHAT_CARD_REGISTRY: Record<string, ChatCardRegistryEntry> = {
           discuss={opts.discuss} />
     ),
   },
+  faq: {
+    mode: 'no-fetch',
+    label: 'FAQ',
+    bareInline: true,
+    render: (chatRef, opts) => (
+      <FaqChatCard chatRef={chatRef} isNewTab={opts.isNewTab} discuss={opts.discuss} />
+    ),
+  },
   hubspot_ticket: {
     mode: 'no-fetch',
     label: 'HubSpot ticket',

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

@@ -345,7 +345,7 @@ export function useRealtimeChunkProcessor(
         }
 
         case 'system': {
-          callbacks.onSystemMessage?.(action.text)
+          callbacks.onSystemMessage?.(action.text, { streamSeq })
           break
         }
 
@@ -354,6 +354,7 @@ export function useRealtimeChunkProcessor(
             ownerType: action.ownerType,
             displayName: action.displayName,
             userId: action.userId,
+            streamSeq,
           })
           break
         }
@@ -363,6 +364,7 @@ export function useRealtimeChunkProcessor(
             ownerType: action.ownerType,
             displayName: action.displayName,
             userId: action.userId,
+            streamSeq,
           })
           break
 

package/src/components/chat/types/api.types.ts

@@ -164,14 +164,17 @@ export interface RealtimeChunkCallbacks {
   onSegmentsUpdate?: (segments: MessageSegment[], metadata?: SegmentsUpdateMetadata) => void
   /** Called when an error is received */
   onError?: (error: string, details?: string) => void
-  /** Called when a user message request is received (echo) */
-  onUserMessage?: (text: string, metadata?: { ownerType?: string; displayName?: string; userId?: string }) => void
+  /** Called when a user message request is received (echo). `streamSeq` (when
+   *  the transport carries one) lets hosts stamp the synthetic so the history
+   *  merge can dedup it against its persisted twin by sequence. */
+  onUserMessage?: (text: string, metadata?: { ownerType?: string; displayName?: string; userId?: string; streamSeq?: number }) => void
   /** Called when TOKEN_USAGE chunk is received with token stats */
   onTokenUsage?: (data: TokenUsageData) => void
-  /** Called when a direct message is received (immediately displayed) */
-  onDirectMessage?: (text: string, metadata?: { ownerType?: string; displayName?: string; userId?: string }) => void
-  /** Called when a system message is received (e.g. "User joined the chat") */
-  onSystemMessage?: (text: string) => void
+  /** Called when a direct message is received (immediately displayed). Carries
+   *  `streamSeq` for the same per-message dedup as `onUserMessage`. */
+  onDirectMessage?: (text: string, metadata?: { ownerType?: string; displayName?: string; userId?: string; streamSeq?: number }) => void
+  /** Called when a system message is received (e.g. "User joined the chat"). */
+  onSystemMessage?: (text: string, metadata?: { streamSeq?: number }) => void
   /** Callback for approval actions */
   onApprove?: (requestId?: string) => Promise<void> | void
   /** Callback for rejection actions */

package/src/components/chat/utils/__tests__/history-merge.test.ts

@@ -363,6 +363,68 @@ describe('mergeHistoryWithRealtime', () => {
       })
       expect(ids(merged)).toEqual([U0.id, A0.id, U1.id, A1.id])
     })
+
+    // The reported reconnect bug: a replayed direct/system message re-mints a
+    // synthetic with a FRESH timestamp (wall-clock can't catch it), so dedup
+    // must be by seq. Direct/system are role 'user' rows persisted with a
+    // lastChunkStreamSeq equal to the realtime chunk's streamSeq.
+    it('drops a replayed direct-message synthetic once history persisted it', () => {
+      const histDirect: TestMessage = { id: 'aaaa0009', role: 'user', content: 'ping from tech', timestamp: t(2100) }
+      const replayedDirect: TestMessage = {
+        id: 'direct-9999-r',
+        role: 'user',
+        content: 'ping from tech',
+        timestamp: t(9999), // re-minted on reconnect replay — newer than the snapshot
+        streamSeq: 80,
+      }
+      const merged = mergeHistoryWithRealtime<TestMessage>({
+        processedHistory: [U0, A0, histDirect],
+        rawHistoryIds: new Set([U0.id, A0.id, histDirect.id]),
+        existingMessages: [U0, A0, histDirect, replayedDirect],
+        streamingMessageId: null,
+        historyFetchedAt: 5000,
+        historyMaxStreamSeq: 80,
+      })
+      expect(ids(merged)).toEqual([U0.id, A0.id, histDirect.id])
+    })
+
+    it('keeps a live direct message history has not persisted yet (no loss)', () => {
+      const liveDirect: TestMessage = {
+        id: 'direct-3000-x',
+        role: 'user',
+        content: 'new tech msg',
+        timestamp: t(3000),
+        streamSeq: 90,
+      }
+      const merged = mergeHistoryWithRealtime<TestMessage>({
+        processedHistory: [U0, A0],
+        existingMessages: [U0, A0, liveDirect],
+        streamingMessageId: null,
+        historyFetchedAt: 5000,
+        historyMaxStreamSeq: 80, // history hasn't reached seq 90 yet
+      })
+      expect(ids(merged)).toContain(liveDirect.id)
+    })
+
+    it('dedups a system-message synthetic by seq coverage', () => {
+      const histSystem: TestMessage = { id: 'aaaa0010', role: 'user', content: 'User joined', timestamp: t(2100) }
+      const synSystem: TestMessage = {
+        id: 'system-9999-r',
+        role: 'user',
+        content: 'User joined',
+        timestamp: t(9999),
+        streamSeq: 70,
+      }
+      const merged = mergeHistoryWithRealtime<TestMessage>({
+        processedHistory: [U0, A0, histSystem],
+        rawHistoryIds: new Set([U0.id, A0.id, histSystem.id]),
+        existingMessages: [U0, A0, histSystem, synSystem],
+        streamingMessageId: null,
+        historyFetchedAt: 5000,
+        historyMaxStreamSeq: 80,
+      })
+      expect(ids(merged)).toEqual([U0.id, A0.id, histSystem.id])
+    })
   })
 })
 

package/src/components/chat/utils/history-merge.ts

@@ -36,14 +36,18 @@ export interface MergeableChatMessage {
 
 /** Ids minted client-side by realtime chunk processors
  *  (`assistant-<ts>-…` placeholder bubbles, `user-<ts>-…` peer messages,
+ *  `direct-<ts>-…` technician direct messages, `system-<ts>-…` system notices,
  *  `error-<ts>` stream errors). They never match the Mongo ObjectIds history
  *  returns for the same turns. This is the cross-host contract every minting
  *  site (lib `use-chat`, Mingo / tickets chunk processors, openframe-chat)
  *  must keep matching — exported so it lives in exactly one place.
+ *  `direct-`/`system-` are persisted (as ADMIN/SYSTEM history rows) and so are
+ *  replayed by JetStream on reconnect; without them here a replayed direct
+ *  message renders twice (its persisted twin + the fresh synthetic).
  *  `welcome-` and `optimistic-` ids are intentionally NOT listed: welcome
  *  bubbles are never persisted server-side, and optimistic user messages are
  *  deduped by content below. */
-export const SYNTHETIC_REALTIME_ID_PREFIXES = ['assistant-', 'user-', 'error-'] as const
+export const SYNTHETIC_REALTIME_ID_PREFIXES = ['assistant-', 'user-', 'direct-', 'system-', 'error-'] as const
 
 function isSyntheticRealtimeId(id: string): boolean {
   return SYNTHETIC_REALTIME_ID_PREFIXES.some((prefix) => id.startsWith(prefix))