@flamingo-stack/openframe-frontend-core 0.0.589 → 0.0.590-2020.5606.1

package/src/components/chat/__tests__/ticket-event.test.ts

@@ -18,6 +18,7 @@ import { describe, expect, it } from 'vitest';
 import { decodeNatsChunk } from '../../../chat-protocol/nats-decoder';
 import { createChatStreamReducer } from '../stream/chat-stream-reducer';
 import type { HistoricalMessage, MessageSegment, TicketEventSegment } from '../types';
+import type { UnifiedChatMessage } from '../types/unified-chat-state.types';
 import { MessageSegmentAccumulator } from '../utils/message-segment-accumulator';
 import { processHistoricalMessages } from '../utils/process-historical-messages';
 
@@ -312,6 +313,112 @@ describe('processHistoricalMessages — ticket event', () => {
   });
 });
 
+describe('processHistoricalMessages — row stream sequence', () => {
+  it('stamps the hydrated card with the row seq (standalone row)', () => {
+    // TICKET_EVENT chunks are standalone, one per row, so the row's
+    // `lastChunkStreamSeq` IS the event's sequence. Without the stamp the
+    // hydrated card never joins a stale-consumer/catch-up replay of the same
+    // chunk in the store, and the replayed copy rendered as a second
+    // identical card (the resolve/reopen duplication).
+    const { messages } = processHistoricalMessages([
+      {
+        id: 'm1',
+        createdAt: '2026-08-31T00:54:00Z',
+        owner: { type: 'ASSISTANT' },
+        lastChunkStreamSeq: 412,
+        messageData: [{ type: 'TICKET_EVENT', kind: 'RESOLVED', actorType: 'AI' } as never],
+      },
+    ]);
+    expect(events(messages[0].content)[0].streamSeq).toBe(412);
+  });
+
+  it('does NOT stamp a bundled row - its seq belongs to the LAST chunk', () => {
+    const { messages } = processHistoricalMessages([
+      {
+        id: 'm1',
+        createdAt: '2026-08-31T00:54:00Z',
+        owner: { type: 'ASSISTANT' },
+        lastChunkStreamSeq: 413,
+        messageData: [
+          { type: 'TICKET_EVENT', kind: 'RESOLVED', actorType: 'AI' } as never,
+          { type: 'TEXT', text: 'trailing text' } as never,
+        ],
+      },
+    ]);
+    expect(events(messages[0].content)[0].streamSeq).toBeUndefined();
+  });
+});
+
+describe('reducer over a hydrated thread — the resolve/reopen duplication', () => {
+  // The reported bug (admin PSA chat, ticket 86ak8a74d; same lib hole as the
+  // desktop dup in 86ak56ehp): reopening a dialog hydrates the persisted
+  // TICKET_EVENT row into the thread, then a consumer created with a stale
+  // `optStartSeq` replays the same chunk. The twins meet ONLY in the store
+  // (a complete hydrated tail seeds no accumulator), so the join must happen
+  // in `appendToTrailingAssistant` - it used to push the replay beside the
+  // hydrated card as a second identical block.
+  const hydratedThread = (card: TicketEventSegment): UnifiedChatMessage[] => [
+    {
+      id: 'assistant-m1',
+      role: 'assistant',
+      content: '',
+      segments: [{ type: 'text', text: 'Excellent! Feel free to reach out.' }, card],
+    },
+  ];
+
+  const replay = (reducer: ReturnType<typeof createChatStreamReducer>, chunk: unknown) => {
+    const event = decodeNatsChunk(chunk);
+    if (event) reducer.apply(event);
+    return reducer.state.messages[reducer.state.messages.length - 1]?.segments ?? [];
+  };
+
+  it('joins the replay with a seq-stamped hydrated card (one card, row time kept)', () => {
+    const reducer = createChatStreamReducer({ transport: 'nats' });
+    reducer.initializeWithState(
+      hydratedThread({
+        type: 'ticket_event',
+        data: { kind: 'RESOLVED', actorType: 'AI' },
+        streamSeq: 412,
+        occurredAt: new Date('2026-08-31T00:54:00Z'),
+      }),
+    );
+    const segments = replay(reducer, { type: 'TICKET_EVENT', kind: 'RESOLVED', actorType: 'AI', streamSeq: 412 });
+    const cards = events(segments);
+    expect(cards).toHaveLength(1);
+    // First-known time wins: the replay only knows its late arrival time.
+    expect(cards[0].occurredAt).toEqual(new Date('2026-08-31T00:54:00Z'));
+    // The reply the user is reading stays intact.
+    expect(segments.find(s => s.type === 'text')).toMatchObject({ text: 'Excellent! Feel free to reach out.' });
+  });
+
+  it('joins the replay with a seq-LESS hydrated twin (rows persisted before the seq stamp)', () => {
+    const reducer = createChatStreamReducer({ transport: 'nats' });
+    reducer.initializeWithState(
+      hydratedThread({
+        type: 'ticket_event',
+        data: { kind: 'RESOLVED', actorType: 'AI' },
+        occurredAt: new Date('2026-08-31T00:54:00Z'),
+      }),
+    );
+    const cards = events(replay(reducer, { type: 'TICKET_EVENT', kind: 'RESOLVED', actorType: 'AI', streamSeq: 412 }));
+    expect(cards).toHaveLength(1);
+    expect(cards[0].streamSeq).toBe(412);
+    expect(cards[0].occurredAt).toEqual(new Date('2026-08-31T00:54:00Z'));
+  });
+
+  it('keeps a genuinely repeated cycle distinct across hydrate + live', () => {
+    // resolve (hydrated, seq-less legacy row) -> live reopen -> live resolve
+    // payload-identical to the first: only the LAST ticket event may
+    // payload-match, so the final resolve renders as its own card.
+    const reducer = createChatStreamReducer({ transport: 'nats' });
+    reducer.initializeWithState(hydratedThread({ type: 'ticket_event', data: { kind: 'RESOLVED', actorType: 'AI' } }));
+    replay(reducer, { type: 'TICKET_EVENT', kind: 'REOPENED', actorType: 'CLIENT', streamSeq: 413 });
+    const cards = events(replay(reducer, { type: 'TICKET_EVENT', kind: 'RESOLVED', actorType: 'AI', streamSeq: 414 }));
+    expect(cards).toHaveLength(3);
+    expect(cards.map(c => c.data.kind)).toEqual(['RESOLVED', 'REOPENED', 'RESOLVED']);
+  });
+});
+
 describe('accumulator — occurredAt across the hydrate/catch-up overlap', () => {
   it('keeps the hydrated row time when the seq-stamped redelivery carries none', () => {
     const accumulator = new MessageSegmentAccumulator();

package/src/components/chat/stream/message-mutations.ts

@@ -95,14 +95,56 @@ function upsertKey(seg: MessageSegment): string | null {
       return `escalated:${seg.data.ticketId}`;
     case 'ticket_event':
       // The stream sequence is the event's only stable id; a seq-less segment
-      // (hydrated history) is pushed raw — `addTicketEvent`'s payload-equality
-      // upsert owns that case.
+      // (a row hydrated without `lastChunkStreamSeq`) is pushed raw and joined
+      // by `seqlessTicketEventTwinIndex` when its replayed copy arrives.
       return seg.streamSeq !== undefined ? `ticket-event:${seg.streamSeq}` : null;
     default:
       return null;
   }
 }
 
+/**
+ * A seq'd ticket event meeting a HYDRATED twin of itself: history stamps the
+ * row's `lastChunkStreamSeq` onto the segment only for standalone rows, and
+ * rows persisted before that field existed hydrate seq-less - so the
+ * `ticket-event:<seq>` key alone cannot join them, and the replayed copy used
+ * to render as a second identical card. Mirror of `addTicketEvent`'s payload
+ * fallback: consider only the LAST ticket_event (older ones may be a genuinely
+ * repeated resolve/reopen cycle) and never collapse two distinct known seqs.
+ */
+function seqlessTicketEventTwinIndex(segments: MessageSegment[], seg: MessageSegment): number {
+  if (seg.type !== 'ticket_event') return -1;
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const s = segments[i];
+    if (s.type !== 'ticket_event') continue;
+    if (
+      s.streamSeq === undefined &&
+      s.data.kind === seg.data.kind &&
+      s.data.actorId === seg.data.actorId &&
+      s.data.actorName === seg.data.actorName &&
+      s.data.actorType === seg.data.actorType &&
+      s.data.reason === seg.data.reason &&
+      s.data.targetStatusKind === seg.data.targetStatusKind
+    ) {
+      return i;
+    }
+    break;
+  }
+  return -1;
+}
+
+/**
+ * First-known time wins, exactly like `addTicketEvent`: the hydrated twin
+ * carries the row's real `createdAt`, while a replay only knows its (late)
+ * arrival time - replacing wholesale would regress the card to arrival time.
+ * Non-ticket-event upserts keep their replace-wholesale semantics.
+ */
+function withFirstKnownOccurredAt(existing: MessageSegment, incoming: MessageSegment): MessageSegment {
+  if (existing.type !== 'ticket_event' || incoming.type !== 'ticket_event') return incoming;
+  const occurredAt = existing.occurredAt ?? incoming.occurredAt;
+  return occurredAt !== undefined ? { ...incoming, occurredAt } : incoming;
+}
+
 /**
  * Append-mode counterpart of `updateTrailingAssistant` for post-MESSAGE_END
  * continuation fragments (`SegmentsUpdateMetadata.append`). Coalesces
@@ -130,8 +172,9 @@ export function appendToTrailingAssistant(
       // Block deltas must be IDEMPOTENT: an emit can be seen twice (live plus
       // the JetStream catch-up replay over hydrated history), so upsert on the
       // block's identity instead of raw-appending a duplicate card.
-      const idx = merged.findIndex(m => upsertKey(m) === key);
-      if (idx !== -1) merged[idx] = seg;
+      let idx = merged.findIndex(m => upsertKey(m) === key);
+      if (idx === -1) idx = seqlessTicketEventTwinIndex(merged, seg);
+      if (idx !== -1) merged[idx] = withFirstKnownOccurredAt(merged[idx], seg);
       else merged.push(seg);
     } else {
       // Other non-text segments are pushed RAW on purpose: EXECUTING↔EXECUTED

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

@@ -315,6 +315,7 @@ function applyHistoryEvent(
   escalatedApprovals?: EscalatedApprovals,
   offerResolutions?: OfferResolutions,
   rowCreatedAt?: Date,
+  rowStreamSeq?: number,
 ): void {
   // batchApprovalsEnabled is owned by the consumer (oss-tenant chat client /
   // openframe-frontend tickets). Defaults to ON so consumers that haven't
@@ -342,12 +343,16 @@ function applyHistoryEvent(
       });
       break;
 
-    // Seq-less on purpose: the persisted row's sequence lives on the message
-    // (`lastChunkStreamSeq`), not in `messageData`. A live redelivery of the
-    // same event matches this segment by payload equality (see
-    // `addTicketEvent`).
+    // `rowStreamSeq` re-stamps the event's JetStream sequence (the persisted
+    // row's `lastChunkStreamSeq` - `messageData` itself does not carry it).
+    // The store's `ticket-event:<seq>` upsert key is the ONLY join between
+    // this hydrated segment and a catch-up/stale-consumer replay of the same
+    // chunk; a seq-less segment never joins, so the replayed copy rendered as
+    // a second identical card (the resolve/reopen duplication). The payload
+    // fallback in `addTicketEvent` cannot own that case: a COMPLETE hydrated
+    // tail seeds no accumulator, so the twins only ever meet in the store.
     case 'ticket-event':
-      // `rowCreatedAt` is the persisted row's own time — without it the card
+      // `rowCreatedAt` is the persisted row's own time - without it the card
       // renders the enclosing assistant bubble's timestamp, i.e. the FIRST
       // row of the turn, and every lifecycle card reads the same stale time.
       accumulator.addTicketEvent(
@@ -359,7 +364,7 @@ function applyHistoryEvent(
           reason: event.reason,
           targetStatusKind: event.targetStatusKind,
         },
-        undefined,
+        rowStreamSeq,
         rowCreatedAt,
       );
       break;
@@ -697,6 +702,13 @@ export function processHistoricalMessages(
           escalatedApprovals,
           offerResolutions,
           new Date(msg.createdAt),
+          // TICKET_EVENT chunks are standalone, one per row, so the row seq IS
+          // the event seq - but vouch for that only when the row holds exactly
+          // one entry: a bundled row's `lastChunkStreamSeq` belongs to its LAST
+          // chunk and could stamp the wrong event.
+          messageDataArray.length === 1 && typeof msg.lastChunkStreamSeq === 'number'
+            ? msg.lastChunkStreamSeq
+            : undefined,
         );
       });