@flamingo-stack/openframe-frontend-core 0.0.508 → 0.0.509

package/src/components/chat/utils/__tests__/segment-accumulator-golden.test.ts

@@ -0,0 +1,270 @@
+/**
+ * Phase-0 GOLDEN CHARACTERIZATION TESTS — `MessageSegmentAccumulator`.
+ *
+ * Pins the CURRENT segment-accumulation semantics before the stream-reader
+ * unification. Each test drives the accumulator through a recorded event
+ * sequence and snapshots the final segment array. Behaviors captured here
+ * (including the implicit approval-flip on tool execution and the batch
+ * no-downgrade rule) are the recorded baseline the future reducer must match.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { createMessageSegmentAccumulator } from '../message-segment-accumulator'
+import type { ToolExecutionSegment, PendingToolCallData } from '../../types'
+
+const executing = (
+  execId: string | undefined,
+  overrides: Partial<ToolExecutionSegment['data']> = {},
+): ToolExecutionSegment => ({
+  type: 'tool_execution',
+  data: {
+    type: 'EXECUTING_TOOL',
+    integratedToolType: 'TACTICAL_RMM',
+    toolFunction: 'run_script',
+    toolTitle: 'Run cleanup script',
+    parameters: { script: 'cleanup.sh' },
+    ...(execId ? { toolExecutionRequestId: execId } : {}),
+    ...overrides,
+  },
+})
+
+const executed = (
+  execId: string | undefined,
+  overrides: Partial<ToolExecutionSegment['data']> = {},
+): ToolExecutionSegment => ({
+  type: 'tool_execution',
+  data: {
+    type: 'EXECUTED_TOOL',
+    integratedToolType: 'TACTICAL_RMM',
+    toolFunction: 'run_script',
+    // Backend omits toolTitle on EXECUTED_TOOL — the accumulator restores it.
+    result: 'Freed 2.3 GB',
+    success: true,
+    ...(execId ? { toolExecutionRequestId: execId } : {}),
+    ...overrides,
+  },
+})
+
+const batchToolCalls: PendingToolCallData[] = [
+  {
+    toolExecutionRequestId: 'exec-a',
+    toolName: 'create_ticket',
+    toolTitle: 'Create ticket',
+    toolExplanation: 'Opens a support ticket',
+    requiresApproval: true,
+    approvalType: 'CLIENT',
+    toolCallArguments: { subject: 'Printer down' },
+  },
+  {
+    toolExecutionRequestId: 'exec-b',
+    toolName: 'read_kb',
+    requiresApproval: false,
+    approvalType: null,
+    toolCallArguments: null,
+  },
+]
+
+describe('MessageSegmentAccumulator — golden sequences', () => {
+  it('coalesces consecutive text deltas into one text segment', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.appendText('Hello')
+    acc.appendText(', ')
+    acc.appendText('world')
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('coalesces thinking deltas, and text after thinking starts a NEW segment', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.appendThinking('Let me think')
+    acc.appendThinking('… ok.')
+    acc.appendText('Answer: ')
+    acc.appendText('42')
+    // A late thinking delta after text starts ANOTHER thinking segment
+    // (append-to-last only merges into a trailing segment of the same type).
+    acc.appendThinking('post-answer thought')
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('merges EXECUTING_TOOL → EXECUTED_TOOL in place by toolExecutionRequestId (title restored)', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.appendText('Running a cleanup now.')
+    acc.addToolExecution(executing('exec-1'))
+    acc.addToolExecution(executed('exec-1'))
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('pairs by (integratedToolType, toolFunction) when no exec id is present (older backends)', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.addToolExecution(executing(undefined))
+    acc.addToolExecution(executed(undefined))
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('EXECUTED with no prior EXECUTING lands as a standalone completed segment', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.addToolExecution(executed('exec-orphan'))
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('CHARACTERIZATION: a LATE standalone EXECUTING after its EXECUTED pushes a NEW executing segment (no in-place downgrade, but a duplicate card appears)', () => {
+    // The no-downgrade rule is enforced INSIDE approval batches
+    // (applyExecutionToBatch); for standalone segments a redelivered
+    // EXECUTING after EXECUTED does NOT downgrade the merged segment —
+    // it appends a fresh EXECUTING segment. Recording as-is, see
+    // unification plan.
+    const acc = createMessageSegmentAccumulator()
+    acc.addToolExecution(executing('exec-1'))
+    acc.addToolExecution(executed('exec-1'))
+    acc.addToolExecution(executing('exec-1'))
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('single approval request → updateApprovalStatus flips status and stamps resolvedByName only on batches', () => {
+    const acc = createMessageSegmentAccumulator({
+      onApprove: async () => {},
+      onReject: async () => {},
+    })
+    acc.addApprovalRequest('req-1', 'systemctl restart nats', 'Restart broker', 'CLIENT')
+    acc.updateApprovalStatus('req-1', 'approved', 'Jane Admin')
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('tracked (pending) approval + processApprovalResult appends a resolved segment', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.trackApprovalRequest('req-2', {
+      command: 'rm -rf /tmp/cache',
+      explanation: 'Clear caches',
+      approvalType: 'CLIENT',
+    })
+    const result = acc.processApprovalResult('req-2', false, 'CLIENT')
+    expect({
+      segments: acc.getSegments(),
+      pendingData: result?.pendingData ?? null,
+      hasPendingAfter: acc.hasPendingApprovals(),
+    }).toMatchSnapshot()
+  })
+
+  it('batch approval with per-tool executions merged into the batch (no standalone segments)', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.addApprovalBatch('batch-1', 'CLIENT', batchToolCalls)
+    acc.updateApprovalStatus('batch-1', 'approved', 'Jane Admin')
+    // Executions matching the batch's toolExecutionRequestIds merge into
+    // `executions` instead of pushing standalone tool_execution segments.
+    acc.addToolExecution(executing('exec-a', { toolFunction: 'create_ticket' }))
+    acc.addToolExecution(
+      executed('exec-a', { toolFunction: 'create_ticket', result: 'Ticket #77 created' }),
+    )
+    acc.addToolExecution(executing('exec-b', { toolFunction: 'read_kb' }))
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('batch no-downgrade rule: a redelivered EXECUTING after EXECUTED keeps the done slot', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.addApprovalBatch('batch-1', 'CLIENT', batchToolCalls, 'approved')
+    acc.addToolExecution(executed('exec-a', { result: 'done!' }))
+    // Late/redelivered EXECUTING for the same exec id — must NOT flip
+    // the slot back to 'executing'.
+    acc.addToolExecution(executing('exec-a'))
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('addApprovalBatch upserts by approvalRequestId (replay path produces ONE batch segment)', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.addApprovalBatch('batch-1', 'CLIENT', batchToolCalls, 'pending')
+    acc.addApprovalBatch('batch-1', 'CLIENT', batchToolCalls, 'approved', {
+      'exec-a': { status: 'done', result: 'ok', success: true },
+    }, 'Jane Admin')
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('implicit resolvePendingApprovalForExecution: a tool execution flips the LATEST pending single approval (NATS-observer behavior)', () => {
+    // An observer (technician mirroring a client chat) may never receive
+    // APPROVAL_RESULT — only the tool's EXECUTING/EXECUTED events. The
+    // accumulator treats a tool execution as implicit approval of the most
+    // recent still-pending single approval gate. Pinning explicitly.
+    const acc = createMessageSegmentAccumulator()
+    acc.addApprovalRequest('req-old', 'echo old', undefined, 'CLIENT', 'rejected')
+    acc.addApprovalRequest('req-1', 'systemctl restart nats', undefined, 'CLIENT', 'pending')
+    acc.addToolExecution(executing('exec-9'))
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('implicit approval flips ONLY the latest pending gate, earlier pending gates stay pending', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.addApprovalRequest('req-1', 'first', undefined, 'CLIENT', 'pending')
+    acc.addApprovalRequest('req-2', 'second', undefined, 'CLIENT', 'pending')
+    acc.addToolExecution(executing('exec-1'))
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('implicit approval does NOT touch approval_batch segments (handled by applyExecutionToBatch only)', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.addApprovalBatch('batch-1', 'CLIENT', batchToolCalls, 'pending')
+    // exec id NOT in the batch → standalone segment path; batch stays pending.
+    acc.addToolExecution(executing('exec-unrelated'))
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('context compaction start → complete replaces the started segment in place', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.appendText('Before compaction')
+    acc.addContextCompaction()
+    acc.completeContextCompaction('Summarized 34 messages')
+    acc.appendText('After compaction')
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('completeContextCompaction with no started segment pushes a completed one', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.completeContextCompaction(undefined)
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('error segments append verbatim', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.appendText('partial answer')
+    acc.addError('Agent crashed', 'boom')
+    expect(acc.getSegments()).toMatchSnapshot()
+  })
+
+  it('flushPendingApprovals emits pending cards for every tracked-but-unresolved approval', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.trackApprovalRequest('req-1', { command: 'cmd-1', approvalType: 'CLIENT' })
+    acc.trackApprovalRequest('req-2', { command: 'cmd-2', explanation: 'why', approvalType: 'ADMIN' })
+    expect(acc.flushPendingApprovals()).toMatchSnapshot()
+  })
+
+  it('replaySegments reproduces a mixed recorded segment array (idempotent replay)', () => {
+    const acc = createMessageSegmentAccumulator()
+    acc.appendThinking('hmm')
+    acc.appendText('Sure — ')
+    acc.addToolExecution(executing('exec-1'))
+    acc.addToolExecution(executed('exec-1'))
+    acc.addApprovalBatch('batch-1', 'CLIENT', batchToolCalls, 'approved', {
+      'exec-a': { status: 'done', result: 'ok', success: true },
+    })
+    acc.appendText('done.')
+    const recorded = acc.getSegments()
+
+    const replayed = createMessageSegmentAccumulator().replaySegments(recorded)
+    expect(replayed).toMatchSnapshot()
+  })
+
+  it('initializeWithState continues an incomplete message across reconnect', () => {
+    const first = createMessageSegmentAccumulator()
+    first.appendText('partial ')
+    first.addToolExecution(executing('exec-1'))
+    const state = first.getState()
+
+    const resumed = createMessageSegmentAccumulator()
+    resumed.initializeWithState({
+      existingSegments: state.segments,
+      pendingApprovals: state.pendingApprovals,
+      executingTools: state.executingTools,
+    })
+    // The EXECUTED for the pre-reconnect EXECUTING merges into it.
+    resumed.addToolExecution(executed('exec-1'))
+    resumed.appendText('and the rest.')
+    expect(resumed.getSegments()).toMatchSnapshot()
+  })
+})

package/src/components/chat/utils/extract-incomplete-message-state.ts

@@ -9,6 +9,18 @@ import type {
   PendingApproval,
   ExecutingToolState,
 } from '../types'
+import type { InitializeExtras } from '../stream/chat-stream-reducer'
+
+/**
+ * What the realtime accumulator needs to RESUME an unfinished turn.
+ *
+ * DERIVED, not restated: this is exactly the reducer's `InitializeExtras`
+ * minus `escalatedApprovals` (which only the live stream can produce — it has
+ * no historical representation to extract). Hosts pass the result straight
+ * into `reducer.initializeWithState(messages, extras)`, so the two must not
+ * drift; a structural coincidence is not a contract.
+ */
+export type IncompleteMessageState = Omit<InitializeExtras, 'escalatedApprovals'>
 
 /**
  * Extract incomplete message state from the last historical assistant message
@@ -16,11 +28,7 @@ import type {
  */
 export function extractIncompleteMessageState(
   lastMessage: ProcessedMessage | undefined
-): {
-  existingSegments?: MessageSegment[]
-  pendingApprovals?: Map<string, PendingApproval>
-  executingTools?: Map<string, ExecutingToolState>
-} | undefined {
+): IncompleteMessageState | undefined {
   if (!lastMessage || lastMessage.role !== 'assistant' || typeof lastMessage.content === 'string') {
     return undefined
   }
@@ -29,8 +37,15 @@ export function extractIncompleteMessageState(
   const pendingApprovals = new Map<string, PendingApproval>()
   const executingTools = new Map<string, ExecutingToolState>()
   let hasIncompleteState = false
+  // "Incomplete" and "the agent is working" are DIFFERENT questions, and only
+  // the second one drives the activity indicator. A pending approval is the
+  // clearest case of incomplete-but-idle: the turn is unfinished precisely
+  // BECAUSE the agent is blocked on the user, and spinning there claims work
+  // that is not happening. Everything below is the complement of that.
+  let agentBusy = false
 
-  segments.forEach(segment => {
+  segments.forEach((segment, index) => {
+    const isLast = index === segments.length - 1
     switch (segment.type) {
       case 'tool_execution':
         if (segment.data.type === 'EXECUTING_TOOL') {
@@ -45,6 +60,8 @@ export function extractIncompleteMessageState(
             parameters: segment.data.parameters,
           })
           hasIncompleteState = true
+          // An EXECUTING with no result: the tool is running right now.
+          agentBusy = true
         }
         break
 
@@ -56,6 +73,17 @@ export function extractIncompleteMessageState(
             approvalType: segment.data.approvalType || 'CLIENT',
           })
           hasIncompleteState = true
+        } else if (isLast && segment.status === 'approved') {
+          // The user said yes and the agent has produced NOTHING since — it is
+          // executing the command. Position is the only signal here: unlike a
+          // batch, a single request carries no execution record, so an approved
+          // request that already ran is recognised by the work that follows it.
+          //
+          // This also has to mark the tail incomplete, or the state never
+          // reaches the reducer at all — and the continuation, when it replays,
+          // must merge into THIS bubble rather than open a second one.
+          hasIncompleteState = true
+          agentBusy = true
         }
         break
 
@@ -72,12 +100,20 @@ export function extractIncompleteMessageState(
         if (segment.status !== 'rejected' && !allDone) {
           hasIncompleteState = true
         }
+        // Approved with tool calls still outstanding — the agent is running
+        // them. The execution record makes this position-independent: once
+        // every call is `done` the batch stops claiming work.
+        if (segment.status === 'approved' && !allDone) {
+          agentBusy = true
+        }
         break
       }
 
       case 'context_compaction':
         if (segment.status === 'started') {
           hasIncompleteState = true
+          // Compaction is the agent's own work, not a wait on the user.
+          agentBusy = true
         }
         break
     }
@@ -91,5 +127,56 @@ export function extractIncompleteMessageState(
     existingSegments: segments,
     pendingApprovals: pendingApprovals.size > 0 ? pendingApprovals : undefined,
     executingTools: executingTools.size > 0 ? executingTools : undefined,
+    ...(agentBusy ? { agentBusy: true } : {}),
+  }
+}
+
+/**
+ * THREAD-level generalization of `extractIncompleteMessageState`: given a
+ * processed thread, look at the TRAILING RUN of consecutive assistant
+ * messages (not just the very last row), flatten it to one segment list, and
+ * ask the single-message extractor whether that tail is unfinished.
+ *
+ * Why the run and not the last row: the backend can split one logical turn
+ * across several assistant messages (a preamble bubble, then the approval
+ * card, then the continuation). The unfinished artifact — a pending approval,
+ * an EXECUTING_TOOL with no result, an open compaction — can therefore sit in
+ * an EARLIER bubble of the same trailing run, and a last-row-only check
+ * reports "complete" while the turn is very much still in flight.
+ *
+ * SSOT for every "is the tail incomplete?" question — the NATS adapter (which
+ * used to inline the single-row check) and hosts replaying a stored thread
+ * both call this instead of re-deriving the walk.
+ *
+ * A trailing non-assistant row (user / error) means the last turn closed →
+ * `undefined`.
+ */
+export function extractIncompleteTailState(
+  messages: readonly ProcessedMessage[] | undefined,
+): IncompleteMessageState | undefined {
+  if (!messages || messages.length === 0) return undefined
+
+  // Walk back over the trailing consecutive assistant run.
+  let start = messages.length
+  while (start > 0 && messages[start - 1]?.role === 'assistant') start -= 1
+  if (start === messages.length) return undefined
+
+  const segments: MessageSegment[] = []
+  for (let i = start; i < messages.length; i += 1) {
+    const content = messages[i]?.content
+    // A string-content assistant row is a plain-text bubble with nothing to
+    // resume; skip it rather than aborting — a later row in the same run may
+    // still hold the unfinished segment.
+    if (Array.isArray(content)) segments.push(...(content as MessageSegment[]))
   }
+  if (segments.length === 0) return undefined
+
+  // Reuse the single-message extractor verbatim by handing it a synthetic
+  // assistant row carrying the flattened run — one incompleteness rule set,
+  // not two.
+  return extractIncompleteMessageState({
+    ...messages[messages.length - 1],
+    role: 'assistant',
+    content: segments,
+  } as ProcessedMessage)
 }

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

@@ -1,4 +1,9 @@
-import type { ApprovalBatchSegment, MessageContent } from '../types'
+import type {
+  ApprovalBatchSegment,
+  ApprovalRequestSegment,
+  MessageContent,
+  ToolExecutionSegment,
+} from '../types'
 
 /**
  * Reconciliation between persisted dialog history (processed GraphQL pages)
@@ -77,6 +82,50 @@ function assistantAnswerText(content: MessageContent): string {
   return parts.join('\n').trim()
 }
 
+/**
+ * Backend request ids carried by a turn's segments — tool-call ids, approval
+ * request ids, batch ids.
+ *
+ * These identify the TURN, which is what lets the merge recognise history's
+ * persisted row and a live synthetic as two copies of the same thing when
+ * their IDS DIFFER. Ids only converge through adoption, and adoption only
+ * happens on a replay (a reload re-streams the turn into the persisted row);
+ * a refetch that lands mid-stream has no replay, so the live copy keeps the
+ * synthetic id the reducer minted.
+ *
+ * Empty for a turn that has produced only text — callers must treat an empty
+ * set as "no signal", never as a match.
+ */
+function turnRequestKeys(content: MessageContent): Set<string> {
+  const keys = new Set<string>()
+  if (!Array.isArray(content)) return keys
+  for (const seg of content) {
+    if (seg.type === 'tool_execution') {
+      const id = (seg as ToolExecutionSegment).data?.toolExecutionRequestId
+      if (id) keys.add(id)
+    } else if (seg.type === 'approval_request') {
+      const id = (seg as ApprovalRequestSegment).data?.requestId
+      if (id) keys.add(id)
+    } else if (seg.type === 'approval_batch') {
+      const data = (seg as ApprovalBatchSegment).data
+      if (data?.approvalRequestId) keys.add(data.approvalRequestId)
+      for (const call of data?.toolCalls ?? []) {
+        if (call?.toolExecutionRequestId) keys.add(call.toolExecutionRequestId)
+      }
+    }
+  }
+  return keys
+}
+
+/** Whether `content` carries any of `keys` — see `turnRequestKeys`. */
+function sharesRequestKey(content: MessageContent, keys: ReadonlySet<string>): boolean {
+  if (keys.size === 0) return false
+  for (const key of turnRequestKeys(content)) {
+    if (keys.has(key)) return true
+  }
+  return false
+}
+
 /** Flattens DESC-sorted message pages (newest page first, newest message
  *  first within a page) into one chronological list. */
 export function flattenMessagePagesChronological<T>(pages: readonly { messages: readonly T[] }[] | undefined): T[] {
@@ -250,13 +299,32 @@ export function mergeHistoryWithRealtime<M extends MergeableChatMessage>(input:
   ) {
     const persistedSize = historyTrailingAssistant.content.length
     const persistedSeq = historyTrailingAssistant.streamSeq ?? 0
+    // Turn identity for a twin that has NOT adopted the persisted id. Adoption
+    // only happens on a REPLAY (a reload re-streams the turn from its
+    // MESSAGE_START into the persisted row); a refetch that lands while the
+    // turn is still streaming has no replay, so the live copy keeps the
+    // synthetic id the reducer minted and the id test above can never match.
+    // Both copies do carry the backend's per-call request ids, which identify
+    // the TURN — the same trick the approval-batch branch plays with
+    // `approvalRequestId`, widened to tool calls.
+    const trailingKeys = turnRequestKeys(historyTrailingAssistant.content)
+    const isSameTurn = (m: M): boolean =>
+      m.id === historyTrailingAssistant.id ||
+      (trailingKeys.size > 0 && sharesRequestKey(m.content, trailingKeys))
     const richerTwin = existingMessages.find(
       (m) =>
         m !== historyTrailingAssistant &&
-        m.id === historyTrailingAssistant.id &&
         m.role === 'assistant' &&
         Array.isArray(m.content) &&
-        (m.content.length > persistedSize ||
+        isSameTurn(m) &&
+        // A STILL-STREAMING twin wins outright: it is the copy the chunks are
+        // landing in, so "richer" is a property it is about to have anyway,
+        // and history's snapshot of a turn in flight is stale by construction.
+        // Without this the same turn rendered TWICE — history's partial copy
+        // beside the live one, their tool rows disagreeing (one pending, one
+        // failed) because each stopped at a different chunk.
+        (m.id === streamingMessageId ||
+          m.content.length > persistedSize ||
           (m.content.length === persistedSize && typeof m.streamSeq === 'number' && m.streamSeq > persistedSeq)),
     )
     if (richerTwin) {
@@ -384,8 +452,20 @@ export function mergeHistoryWithRealtime<M extends MergeableChatMessage>(input:
       if (typeof m.streamSeq === 'number' && anyHistoryRowSeq) {
         const roleMax = historyMaxSeqByRole.get(m.role) ?? 0
         covered = roleMax > 0 && roleMax >= m.streamSeq
-      } else if (typeof m.streamSeq === 'number' && historyMaxStreamSeq > 0) {
-        covered = historyMaxStreamSeq >= m.streamSeq
+      } else if (typeof m.streamSeq === 'number') {
+        // This synthetic carries its own seq, but no history row does. Decide
+        // against the global when it exists — and when it does NOT
+        // (`historyMaxStreamSeq === 0`), that is not "unknown, guess by clock":
+        // it is positive evidence that nothing in the snapshot has reached any
+        // seq at all, so the snapshot cannot contain this turn. KEEP it.
+        //
+        // This is the mid-stream refetch: the only persisted row of a turn in
+        // flight is the user MESSAGE_REQUEST, which the backend does not stamp,
+        // so the max is 0 while live bubbles keep arriving. Falling through to
+        // wall-clock there judged every one of them "older than the fetch
+        // instant, therefore persisted" and dropped all but the single
+        // `streamingMessageId` — the thread collapsed to the user's prompt.
+        covered = historyMaxStreamSeq > 0 && historyMaxStreamSeq >= m.streamSeq
       } else {
         covered =
           historyCoversRealtime !== null

package/src/components/chat/utils/index.ts

@@ -3,14 +3,9 @@
  * Export all utilities for processing chat messages
  */
 
-// Chunk parsing utilities
-export {
-  parseChunkToAction,
-  isControlChunk,
-  isErrorChunk,
-  isMetadataChunk,
-  extractTextFromChunk,
-} from './chunk-parser'
+// NOTE: NATS chunk parsing lives in `chat-protocol/nats-decoder`
+// (`decodeNatsChunk`) — the legacy `chunk-parser` module was deleted once the
+// reducer became the single reading path.
 
 // Segment accumulator
 export {
@@ -24,11 +19,13 @@ export {
   processHistoricalMessages,
   extractErrorMessages,
   processHistoricalMessagesWithErrors,
+  decodeHistoricalMessageData,
 } from './process-historical-messages'
 
 // Incomplete message state extraction
 export {
   extractIncompleteMessageState,
+  extractIncompleteTailState,
 } from './extract-incomplete-message-state'
 
 // History <-> realtime reconciliation