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

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

@@ -164,17 +164,14 @@ 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). `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 a user message request is received (echo) */
+  onUserMessage?: (text: string, metadata?: { ownerType?: string; displayName?: string; userId?: string }) => void
   /** Called when TOKEN_USAGE chunk is received with token stats */
   onTokenUsage?: (data: TokenUsageData) => 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
+  /** 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
   /** 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,68 +363,6 @@ 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,18 +36,14 @@ 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-', 'direct-', 'system-', 'error-'] as const
+export const SYNTHETIC_REALTIME_ID_PREFIXES = ['assistant-', 'user-', 'error-'] as const
 
 function isSyntheticRealtimeId(id: string): boolean {
   return SYNTHETIC_REALTIME_ID_PREFIXES.some((prefix) => id.startsWith(prefix))