@flamingo-stack/openframe-frontend-core 0.0.278 → 0.0.279

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flamingo-stack/openframe-frontend-core",
-  "version": "0.0.278",
+  "version": "0.0.279",
   "description": "Shared design system and components for all Flamingo platforms",
   "type": "module",
   "main": "./dist/index.js",

package/src/components/chat/chat-message-enhanced.tsx

@@ -492,6 +492,7 @@ const ChatMessageEnhanced = forwardRef<HTMLDivElement, ChatMessageEnhancedProps>
                       key={index}
                       data={segment.data}
                       status={segment.status}
+                      resolvedByName={segment.resolvedByName}
                       onApprove={segment.onApprove}
                       onReject={segment.onReject}
                     />

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

@@ -12,7 +12,7 @@ import {
   createMessageSegmentAccumulator,
 } from '../utils/message-segment-accumulator'
 import { MESSAGE_TYPE } from '../types'
-import type { UseRealtimeChunkProcessorReturn, UseRealtimeChunkProcessorOptions, ChatApprovalStatus, PendingToolCallData } from '../types'
+import type { UseRealtimeChunkProcessorReturn, UseRealtimeChunkProcessorOptions, ChatApprovalStatus, PendingToolCallData, MessageSegment, SegmentsUpdateMetadata } from '../types'
 import { getCommandText } from '../utils/tool-call-helpers'
 
 // Actions allowed through once the dialog is in direct mode. Everything else is
@@ -107,6 +107,17 @@ export function useRealtimeChunkProcessor(
 
       const accumulator = accumulatorRef.current
 
+      // streamSeq of the chunk currently being processed (JetStream only).
+      // Only content emissions below carry it through to the host, so the
+      // streaming bubble is stamped with the highest CONTENT seq it saw — the
+      // non-persisted MESSAGE_END / TOKEN_USAGE chunks never reach emitSegments.
+      const streamSeq =
+        chunk && typeof chunk === 'object' && typeof (chunk as { streamSeq?: unknown }).streamSeq === 'number'
+          ? (chunk as { streamSeq: number }).streamSeq
+          : undefined
+      const emitSegments = (s: MessageSegment[], meta?: SegmentsUpdateMetadata) =>
+        callbacks.onSegmentsUpdate?.(s, streamSeq != null ? { ...meta, streamSeq } : meta)
+
       if (action.action === 'direct_message') sawDirectMessageRef.current = true
 
       if ((directModeFlagRef.current || sawDirectMessageRef.current) && !DIRECT_MODE_ALLOWED.has(action.action)) {
@@ -146,9 +157,9 @@ export function useRealtimeChunkProcessor(
           // spawn the first assistant bubble — otherwise appendSegmentsToLastAssistant
           // silently drops the chunk when no last assistant exists.
           if (isInStreamRef.current || !hasEverStreamedRef.current) {
-            callbacks.onSegmentsUpdate?.(segments)
+            emitSegments(segments)
           } else {
-            callbacks.onSegmentsUpdate?.([{ type: 'text', text: action.text }], { append: true })
+            emitSegments([{ type: 'text', text: action.text }], { append: true })
           }
           break
         }
@@ -156,9 +167,9 @@ export function useRealtimeChunkProcessor(
         case 'thinking': {
           const segments = accumulator.appendThinking(action.text)
           if (isInStreamRef.current || !hasEverStreamedRef.current) {
-            callbacks.onSegmentsUpdate?.(segments)
+            emitSegments(segments)
           } else {
-            callbacks.onSegmentsUpdate?.([{ type: 'thinking', text: action.text }], { append: true })
+            emitSegments([{ type: 'thinking', text: action.text }], { append: true })
           }
           break
         }
@@ -178,7 +189,7 @@ export function useRealtimeChunkProcessor(
           // cross-message scan is first-match-wins and could touch a
           // same-execId segment in a prior bubble (agent retry case).
           const segments = accumulator.addToolExecution(action.segment)
-          callbacks.onSegmentsUpdate?.(segments)
+          emitSegments(segments)
           break
         }
 
@@ -195,7 +206,7 @@ export function useRealtimeChunkProcessor(
               approvalType,
               status as ChatApprovalStatus
             )
-            callbacks.onSegmentsUpdate?.(segments)
+            emitSegments(segments)
           } else {
             // Track as escalated
             pendingEscalatedRef.current.set(requestId, { command, explanation, approvalType })
@@ -229,7 +240,7 @@ export function useRealtimeChunkProcessor(
 
           if (batchApprovalsEnabled) {
             const segments = accumulator.addApprovalBatch(requestId, approvalType, toolCalls, status)
-            callbacks.onSegmentsUpdate?.(segments)
+            emitSegments(segments)
             break
           }
 
@@ -248,12 +259,12 @@ export function useRealtimeChunkProcessor(
               status,
             )
           }
-          callbacks.onSegmentsUpdate?.(segments)
+          emitSegments(segments)
           break
         }
 
         case 'approval_result': {
-          const { requestId, approved, approvalType } = action
+          const { requestId, approved, approvalType, resolvedByName } = action
           const escalatedData = pendingEscalatedRef.current.get(requestId)
           const status: ChatApprovalStatus = approved ? 'approved' : 'rejected'
 
@@ -272,8 +283,10 @@ export function useRealtimeChunkProcessor(
                   escalatedData.approvalType,
                   escalatedData.toolCalls,
                   status,
+                  undefined,
+                  resolvedByName,
                 )
-                callbacks.onSegmentsUpdate?.(segments)
+                emitSegments(segments)
               } else {
                 let segments = accumulator.getSegments()
                 for (const call of escalatedData.toolCalls) {
@@ -286,7 +299,7 @@ export function useRealtimeChunkProcessor(
                     status,
                   )
                 }
-                callbacks.onSegmentsUpdate?.(segments)
+                emitSegments(segments)
               }
             } else {
               const segments = accumulator.addApprovalRequest(
@@ -296,12 +309,12 @@ export function useRealtimeChunkProcessor(
                 escalatedData.approvalType,
                 status,
               )
-              callbacks.onSegmentsUpdate?.(segments)
+              emitSegments(segments)
             }
           } else {
             // Always keep the in-memory accumulator in sync so a following
             // text/tool chunk replays the resolved status into the message.
-            accumulator.updateApprovalStatus(requestId, status)
+            accumulator.updateApprovalStatus(requestId, status, resolvedByName)
             // When the consumer wires cross-message resolution via
             // `onApprovalResolved`, skip `onSegmentsUpdate` here: this path
             // routes through `ensureAssistantMessage` + `updateStreamingMessageSegments`,
@@ -309,10 +322,10 @@ export function useRealtimeChunkProcessor(
             // accumulator's segments into it — turning a status flip into a
             // bubble overwrite that wipes the original card.
             if (!callbacks.onApprovalResolved) {
-              callbacks.onSegmentsUpdate?.(accumulator.getSegments())
+              emitSegments(accumulator.getSegments())
             }
           }
-          callbacks.onApprovalResolved?.(requestId, status, approvalType)
+          callbacks.onApprovalResolved?.(requestId, status, approvalType, resolvedByName)
           break
         }
 
@@ -326,7 +339,7 @@ export function useRealtimeChunkProcessor(
             }
           }
           const segments = accumulator.addError(action.error, message)
-          callbacks.onSegmentsUpdate?.(segments)
+          emitSegments(segments)
           callbacks.onError?.(action.error, message)
           break
         }
@@ -360,14 +373,14 @@ export function useRealtimeChunkProcessor(
         case 'context_compaction_start': {
           const standalone = !isInStreamRef.current
           const segments = accumulator.addContextCompaction()
-          callbacks.onSegmentsUpdate?.(segments, standalone ? { append: true, isCompacting: true } : undefined)
+          emitSegments(segments, standalone ? { append: true, isCompacting: true } : undefined)
           break
         }
 
         case 'context_compaction_end': {
           const standalone = !isInStreamRef.current
           const segments = accumulator.completeContextCompaction(action.summary)
-          callbacks.onSegmentsUpdate?.(segments, standalone ? { append: true, isCompacting: true } : undefined)
+          emitSegments(segments, standalone ? { append: true, isCompacting: true } : undefined)
           break
         }
 
@@ -395,8 +408,8 @@ export function useRealtimeChunkProcessor(
   }, [])
 
   const updateApprovalStatus = useCallback(
-    (requestId: string, status: ChatApprovalStatus) => {
-      return accumulatorRef.current.updateApprovalStatus(requestId, status)
+    (requestId: string, status: ChatApprovalStatus, resolvedByName?: string | null) => {
+      return accumulatorRef.current.updateApprovalStatus(requestId, status, resolvedByName)
     },
     []
   )

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

@@ -146,6 +146,11 @@ export interface SegmentsUpdateMetadata {
   append?: boolean
   /** The update was triggered by context compaction */
   isCompacting?: boolean
+  /** streamSeq of the content chunk that produced this update, when the
+   *  transport carries one (JetStream). Hosts stamp it onto the streaming
+   *  message so `mergeHistoryWithRealtime` can dedup per-message against
+   *  persisted history. Undefined for legacy NATS chunks. */
+  streamSeq?: number
 }
 
 export interface RealtimeChunkCallbacks {
@@ -183,7 +188,7 @@ export interface RealtimeChunkCallbacks {
    * a new assistant message is streaming). Idempotent — safe to no-op if no
    * matching segment is found dialog-wide.
    */
-  onApprovalResolved?: (requestId: string, status: ChatApprovalStatus, approvalType: string) => void
+  onApprovalResolved?: (requestId: string, status: ChatApprovalStatus, approvalType: string, resolvedByName?: string | null) => void
   /**
    * Called whenever an `EXECUTED_TOOL` chunk is processed. Lets consumers
    * merge the result into the originating `EXECUTING_TOOL` (or batch
@@ -267,7 +272,7 @@ export interface UseRealtimeChunkProcessorReturn {
   /** Reset the accumulator */
   reset: () => void
   /** Update approval status for a request */
-  updateApprovalStatus: (requestId: string, status: ChatApprovalStatus) => MessageSegment[]
+  updateApprovalStatus: (requestId: string, status: ChatApprovalStatus, resolvedByName?: string | null) => MessageSegment[]
   /** Get pending approval requests */
   getPendingApprovals: () => Map<
     string,

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

@@ -107,6 +107,8 @@ export interface ApprovalResultData {
   approvalRequestId: string
   approved: boolean
   approvalType?: string
+  /** Display name of the user who resolved the request; null/absent for system actions. */
+  resolvedByName?: string | null
 }
 
 /**
@@ -177,6 +179,8 @@ export type ApprovalBatchSegment = {
   type: 'approval_batch'
   data: ApprovalBatchData
   status?: ChatApprovalStatus
+  /** Display name of the user who resolved the request; set when the batch is resolved (null/absent for system actions). */
+  resolvedByName?: string | null
   onApprove?: (requestId?: string) => void | Promise<void>
   onReject?: (requestId?: string) => void | Promise<void>
 }
@@ -250,6 +254,8 @@ export interface ApprovalResultMessageData extends MessageDataBase {
   approvalRequestId?: string
   approved?: boolean
   approvalType?: string
+  /** Display name of the user who resolved the request; null/absent for system actions. */
+  resolvedByName?: string | null
 }
 
 export interface ErrorMessageData extends MessageDataBase {
@@ -337,6 +343,10 @@ export interface Message {
   authorType?: AuthorType
   timestamp?: Date
   avatar?: string | null
+  /** Highest CONTENT chunk streamSeq that composed this message. Stamped on
+   *  realtime synthetics so `mergeHistoryWithRealtime` can decide history
+   *  coverage per-message (see `MergeableChatMessage.streamSeq`). */
+  streamSeq?: number
   /** Per-row metadata for inline entity-card rendering on this message
    *  (v6.1 §B.2.6). Keyed by `<documentType>:<primaryKey>`. Optional —
    *  user messages and legacy turns omit this field. The host's

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

@@ -56,6 +56,8 @@ export interface ChunkData {
   command?: string
   explanation?: string
   approved?: boolean
+  /** On APPROVAL_RESULT chunks: display name of the user who resolved the request. */
+  resolvedByName?: string
   toolCalls?: any[]
   modelName?: string
   providerName?: string

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

@@ -19,7 +19,7 @@ export type ParsedChunkAction =
   | { action: 'tool_execution'; segment: ToolExecutionSegment }
   | { action: 'approval_request'; requestId: string; command: string; explanation?: string; approvalType: string }
   | { action: 'approval_batch'; requestId: string; approvalType: string; toolCalls: PendingToolCallData[] }
-  | { action: 'approval_result'; requestId: string; approved: boolean; approvalType: string }
+  | { action: 'approval_result'; requestId: string; approved: boolean; approvalType: string; resolvedByName?: string | null }
   | { action: 'message_request'; text: string; ownerType?: string; displayName?: string; userId?: string }
   | { action: 'token_usage'; data: TokenUsageData }
   | { action: 'direct_message'; text: string; ownerType?: string; displayName?: string; userId?: string }

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

@@ -294,6 +294,76 @@ describe('mergeHistoryWithRealtime', () => {
     })
     expect(ids(merged)).toContain(welcome.id)
   })
+
+  // Production reality: the client consumes the non-persisted MESSAGE_END /
+  // final TOKEN_USAGE chunks, so `realtimeSeenStreamSeq` always ends up ABOVE
+  // `historyMaxStreamSeq` (no persisted message can carry the tail's seq).
+  // The single global coverage signal therefore reads "not covered" forever
+  // and a non-trailing synthetic survives next to its persisted twin (the
+  // reported duplication). The per-message `streamSeq` makes the decision
+  // exact and turn-local.
+  describe('per-message streamSeq coverage', () => {
+    const U2b: TestMessage = { id: 'aaaa0006', role: 'user', content: 'third question', timestamp: t(3000) }
+    const A2b: TestMessage = { id: 'aaaa0007', role: 'assistant', content: txt('history three'), timestamp: t(3100) }
+
+    it('drops an earlier finished synthetic by its own seq even though the global seq reads not-covered', () => {
+      const synEarly: TestMessage = { id: 'assistant-2100-x', role: 'assistant', content: txt('second answer'), timestamp: t(2100), streamSeq: 40 }
+      const synLate: TestMessage = { id: 'assistant-3100-x', role: 'assistant', content: txt('realtime three'), timestamp: t(3100), streamSeq: 80 }
+      const merged = mergeHistoryWithRealtime<TestMessage>({
+        processedHistory: [U0, A0, U1, A1, U2b, A2b],
+        rawHistoryIds: new Set([U0.id, A0.id, U1.id, A1.id, U2b.id, A2b.id]),
+        existingMessages: [U0, A0, U1, A1, U2b, A2b, synEarly, synLate],
+        streamingMessageId: null,
+        historyFetchedAt: 9000,
+        historyMaxStreamSeq: 80, // both turns fully persisted
+        realtimeSeenStreamSeq: 82, // biased past 80 by the consumed MESSAGE_END
+      })
+      // Global seq (80 >= 82) is false, but per-message seqs (40, 80) are both <= 80.
+      expect(ids(merged)).toEqual([U0.id, A0.id, U1.id, A1.id, U2b.id, A2b.id])
+    })
+
+    it('drops a partial mid-stream synthetic in favour of the full persisted turn', () => {
+      const partial: TestMessage = { id: 'assistant-2100-x', role: 'assistant', content: txt('second ans'), timestamp: t(2100), streamSeq: 50 }
+      const merged = mergeHistoryWithRealtime<TestMessage>({
+        processedHistory: [U0, A0, U1, A1],
+        rawHistoryIds: new Set([U0.id, A0.id, U1.id, A1.id]),
+        existingMessages: [U0, A0, U1, A1, partial],
+        streamingMessageId: null,
+        historyFetchedAt: 9000,
+        historyMaxStreamSeq: 80,
+        realtimeSeenStreamSeq: 82,
+      })
+      expect(ids(merged)).toEqual([U0.id, A0.id, U1.id, A1.id])
+    })
+
+    it('keeps a still-streaming later turn while dropping an earlier finished one', () => {
+      const synEarly: TestMessage = { id: 'assistant-2100-x', role: 'assistant', content: txt('second answer'), timestamp: t(2100), streamSeq: 40 }
+      const synLive: TestMessage = { id: 'assistant-3100-x', role: 'assistant', content: txt('third in progress'), timestamp: t(3100), streamSeq: 70 }
+      const merged = mergeHistoryWithRealtime<TestMessage>({
+        processedHistory: [U0, A0, U1, A1], // only turn 1 persisted so far
+        rawHistoryIds: new Set([U0.id, A0.id, U1.id, A1.id]),
+        existingMessages: [U0, A0, U1, A1, synEarly, synLive],
+        streamingMessageId: null,
+        historyFetchedAt: 9000,
+        historyMaxStreamSeq: 40, // turn 2 not persisted yet
+        realtimeSeenStreamSeq: 70,
+      })
+      // synEarly (40 <= 40) is covered and dropped; synLive (70 > 40) survives.
+      expect(ids(merged)).toEqual([U0.id, A0.id, U1.id, A1.id, synLive.id])
+    })
+
+    it('falls back to the global seq for an unstamped synthetic (legacy NATS)', () => {
+      const merged = mergeHistoryWithRealtime<TestMessage>({
+        processedHistory: [U0, A0, U1, A1],
+        existingMessages: [U0, A0, OPT1, SYN1], // SYN1 has no streamSeq
+        streamingMessageId: null,
+        historyFetchedAt: 5000,
+        historyMaxStreamSeq: 80,
+        realtimeSeenStreamSeq: 80,
+      })
+      expect(ids(merged)).toEqual([U0.id, A0.id, U1.id, A1.id])
+    })
+  })
 })
 
 describe('computeHistoryPrepend', () => {

package/src/components/chat/utils/chunk-parser.ts

@@ -122,13 +122,24 @@ export function parseChunkToAction(chunk: unknown): ParsedChunkAction | null {
       }
     }
       
-    case MESSAGE_TYPE.APPROVAL_RESULT:
+    case MESSAGE_TYPE.APPROVAL_RESULT: {
+      // The realtime NATS chunk carries the resolver's name as `displayName`; the
+      // persisted GraphQL message exposes the same value as `resolvedByName`. Accept
+      // either so realtime and history-replay render "by {name}" identically.
+      const resolvedByName =
+        typeof data.resolvedByName === 'string'
+          ? data.resolvedByName
+          : typeof data.displayName === 'string'
+            ? data.displayName
+            : undefined
       return {
         action: 'approval_result',
         requestId: data.approvalRequestId || data.approval_request_id || '',
         approved: data.approved === true,
         approvalType: data.approvalType || 'CLIENT',
+        resolvedByName,
       }
+    }
       
     case MESSAGE_TYPE.ERROR:
       return {

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

@@ -24,6 +24,14 @@ export interface MergeableChatMessage {
   role: string
   content: MessageContent
   timestamp?: Date
+  /** Highest CONTENT chunk streamSeq that composed this message (text / tool /
+   *  approval / error / compaction — never the non-persisted MESSAGE_END /
+   *  TOKEN_USAGE control chunks). Hosts stamp it on realtime synthetics so the
+   *  merge can decide coverage per-message: a synthetic is in history once
+   *  `historyMaxStreamSeq >= streamSeq`. Optional — absent on history messages
+   *  and on hosts that don't stamp it (those fall back to the global seq /
+   *  wall-clock rule). */
+  streamSeq?: number
 }
 
 /** Ids minted client-side by realtime chunk processors
@@ -216,15 +224,27 @@ export function mergeHistoryWithRealtime<M extends MergeableChatMessage>(input:
     // twice; one the snapshot cannot contain yet must be kept or a message
     // the user already saw is lost, with no realtime replay to restore it
     // (JetStream resumes after the highest seq this client has consumed).
-    // Decided by seq coverage when known, wall-clock otherwise.
+    // Decided PER-MESSAGE by its own content seq when stamped, else the global
+    // seq coverage, else wall-clock.
     if (isSyntheticRealtimeId(m.id) && m.id !== streamingMessageId) {
       // A non-streaming synthetic that re-renders the trailing persisted assistant verbatim is its
       // twin no matter what the seq signal says — drop it (covers the persistence-lag gap).
       if (m.role === 'assistant' && trailingAssistantText && assistantAnswerText(m.content) === trailingAssistantText) {
         return false
       }
+      // Per-message coverage: the synthetic carries the highest CONTENT seq
+      // that built it (never the MESSAGE_END/TOKEN_USAGE tail), so history has
+      // it once its max persisted seq reaches that. This is exact per-turn —
+      // it drops earlier finished turns while keeping a later still-streaming
+      // one, which the single global `realtimeSeenStreamSeq` (biased upward by
+      // the tail the client consumed) cannot distinguish. Falls back to the
+      // global coverage / wall-clock for unstamped synthetics (legacy NATS).
       const covered =
-        historyCoversRealtime !== null ? historyCoversRealtime : (m.timestamp?.getTime() ?? 0) <= historyFetchedAt
+        typeof m.streamSeq === 'number' && historyMaxStreamSeq > 0
+          ? historyMaxStreamSeq >= m.streamSeq
+          : historyCoversRealtime !== null
+            ? historyCoversRealtime
+            : (m.timestamp?.getTime() ?? 0) <= historyFetchedAt
       if (covered) return false
     }
     return true

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

@@ -320,6 +320,7 @@ export class MessageSegmentAccumulator {
     toolCalls: PendingToolCallData[],
     status: ChatApprovalStatus = 'pending',
     executions?: Record<string, ApprovalBatchExecutionState>,
+    resolvedByName?: string | null,
   ): MessageSegment[] {
     const existingIndex = this.segments.findIndex(
       (s): s is ApprovalBatchSegment =>
@@ -338,6 +339,7 @@ export class MessageSegmentAccumulator {
           ...(mergedExecutions ? { executions: mergedExecutions } : {}),
         },
         status,
+        resolvedByName: resolvedByName ?? existing.resolvedByName,
         onApprove: this.callbacks.onApprove,
         onReject: this.callbacks.onReject,
       }
@@ -353,6 +355,7 @@ export class MessageSegmentAccumulator {
         ...(executions ? { executions } : {}),
       },
       status,
+      resolvedByName,
       onApprove: this.callbacks.onApprove,
       onReject: this.callbacks.onReject,
     }
@@ -396,15 +399,17 @@ export class MessageSegmentAccumulator {
   }
 
   /**
-   * Update status of an existing approval segment (single or batch)
+   * Update status of an existing approval segment (single or batch).
+   * `resolvedByName` (when provided) is stamped onto the matching batch segment so the
+   * resolved card shows "by {name}"; omit it to leave any existing value untouched.
    */
-  updateApprovalStatus(requestId: string, status: ChatApprovalStatus): MessageSegment[] {
+  updateApprovalStatus(requestId: string, status: ChatApprovalStatus, resolvedByName?: string | null): MessageSegment[] {
     this.segments = this.segments.map(segment => {
       if (segment.type === 'approval_request' && segment.data.requestId === requestId) {
         return { ...segment, status }
       }
       if (segment.type === 'approval_batch' && segment.data.approvalRequestId === requestId) {
-        return { ...segment, status }
+        return { ...segment, status, resolvedByName: resolvedByName ?? segment.resolvedByName }
       }
       return segment
     })
@@ -517,13 +522,14 @@ export class MessageSegmentAccumulator {
           break
         }
         case 'approval_batch': {
-          const { data, status } = segment
+          const { data, status, resolvedByName } = segment
           this.addApprovalBatch(
             data.approvalRequestId,
             data.approvalType,
             data.toolCalls,
             status,
             data.executions,
+            resolvedByName,
           )
           break
         }

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

@@ -330,6 +330,7 @@ function processMessageData(
       if ('approvalRequestId' in data && data.approvalRequestId) {
         const existingStatus = approvalStatuses[data.approvalRequestId] as ChatApprovalStatus | undefined
         const status: ChatApprovalStatus = existingStatus || (data.approved ? 'approved' : 'rejected')
+        const resolvedByName = 'resolvedByName' in data ? data.resolvedByName : undefined
         const escalatedData = escalatedApprovals?.get(data.approvalRequestId)
 
         if (escalatedData?.toolCalls && escalatedData.toolCalls.length > 0) {
@@ -339,6 +340,8 @@ function processMessageData(
               escalatedData.approvalType,
               escalatedData.toolCalls,
               status,
+              undefined,
+              resolvedByName,
             )
           } else {
             for (const call of escalatedData.toolCalls) {
@@ -368,7 +371,7 @@ function processMessageData(
         // If a segment with this id is already present (batch or legacy), just flip its status.
         // updateApprovalStatus matches both `approval_batch` and `approval_request` segments.
         const before = accumulator.getSegments()
-        const after = accumulator.updateApprovalStatus(data.approvalRequestId, status)
+        const after = accumulator.updateApprovalStatus(data.approvalRequestId, status, resolvedByName)
         const updatedExisting = before.some((s, i) => after[i] !== s)
         if (updatedExisting) break