@flamingo-stack/openframe-frontend-core 0.0.490 → 0.0.492-1506.3956.1

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
   }
@@ -92,4 +100,54 @@ export function extractIncompleteMessageState(
     pendingApprovals: pendingApprovals.size > 0 ? pendingApprovals : undefined,
     executingTools: executingTools.size > 0 ? executingTools : undefined,
   }
+}
+
+/**
+ * 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/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