@flamingo-stack/openframe-frontend-core 0.0.532-snapshot.20260811155109 → 0.0.532

package/src/components/chat/hooks/use-sse-chat-adapter.ts

@@ -59,7 +59,6 @@ import type { MessageSegment } from '../types/message.types'
 import { useSlashCommandRegistry, type SlashCommandSummary } from './use-slash-commands'
 import { chatAuthedFetch } from '../utils/chat-authed-fetch'
 import type { ScrollAnchor } from '../utils/scroll-anchor'
-import { buildConfirmToolBody, readServerErrorMessage } from '../../../chat-protocol/confirm-tool'
 import { createSseFrameDecoder } from '../../../chat-protocol/decode'
 import type { ChatStreamEvent } from '../../../chat-protocol/events'
 import {
@@ -438,11 +437,13 @@ export function useSseChatAdapter(
         ? endpointsRef.current.approvalToolUrl
         : endpointsRef.current.chatStreamUrl
       const requestBody = approvalAction
-        ? // Shared with every other transport that resolves a hub proposal —
-          // the body shape is the hub's, not this adapter's. `conversationId`
-          // is always present here: an approval can only happen inside an
-          // established conversation (the proposal turn captured the id).
-          buildConfirmToolBody({ ...approvalAction, conversationId })
+        ? {
+            proposal_id: approvalAction.proposalId,
+            action: approvalAction.action,
+            // Always present here — an approval can only happen inside an
+            // established conversation (the proposal turn captured the id).
+            conversationId,
+          }
         : {
             messages: [{ role: 'user', content: text }],
             ...(commandOverride ? { commandOverride } : {}),
@@ -475,7 +476,15 @@ export function useSseChatAdapter(
           // `{error, code}`) — a bare "Chat request failed: 409" told
           // the user nothing when e.g. a batch approval expired; the
           // server ships real copy ("This approval expired — ...").
-          const serverMessage = await readServerErrorMessage(response)
+          let serverMessage: string | null = null
+          try {
+            const errBody = (await response.json()) as { error?: unknown }
+            if (typeof errBody?.error === 'string' && errBody.error.length > 0) {
+              serverMessage = errBody.error
+            }
+          } catch {
+            /* non-JSON error body — fall through to the generic copy */
+          }
           throw new Error(serverMessage ?? `Chat request failed: ${response.status}`)
         }
         const reader = response.body?.getReader()

package/src/components/chat/stream/chat-stream-reducer.ts

@@ -58,8 +58,6 @@ import {
 import { getCommandText } from '../utils/tool-call-helpers'
 import { parseScrollAnchor, type ScrollAnchor } from '../utils/scroll-anchor'
 import { escapeThinkingTags } from '../../../chat-protocol/decode'
-import { isGuideOrigin } from '../../../chat-protocol/events'
-import { approvalDisplaysInline, guideApprovalOrigin } from '../utils/approval-display'
 import { buildChatRefKey } from '../types/chat.types'
 import type {
   ApprovalBatchSegment,
@@ -164,15 +162,6 @@ export interface ChatReducerState {
     contextWindowMaxTokens: number | null
   } | null
   approvalStatuses: Record<string, ChatApprovalStatus>
-  /**
-   * Hub conversation id for the Product Guide half of this dialog, learned from
-   * a guide metadata frame. The hub mints it and requires it back on every
-   * confirm-tool call, so a host resolving a guide approval card reads it from
-   * here. Null until a guide turn has streamed — an approval that arrives from
-   * history (after a reload) has no live frame to learn it from, which is why
-   * the agent should also expose it per dialog.
-   */
-  guideConversationId: string | null
 }
 
 /** Escalated-approval bookkeeping entry (mirrors the legacy processor). */
@@ -531,7 +520,6 @@ export function createChatStreamReducer(
   let streamingPhase: StreamingPhase = 'idle'
   let dialogTokenUsage: DialogTokenUsage | null = null
   let liveModel: ChatReducerState['liveModel'] = null
-  let guideConversationId: string | null = null
   let approvalStatuses: Record<string, ChatApprovalStatus> = {
     ...(options.approvalStatuses ?? {}),
   }
@@ -694,7 +682,6 @@ export function createChatStreamReducer(
         dialogTokenUsage,
         liveModel,
         approvalStatuses,
-        guideConversationId,
       }
     }
     return stateCache
@@ -1002,17 +989,6 @@ export function createChatStreamReducer(
       }
 
       case 'metadata': {
-        // A guide metadata event carries ONLY the hub's conversation id (the
-        // decoder strips the rest): record it and stop. Falling through would
-        // rebuild `liveModel` from an event with no model in it and blank the
-        // dialog's model badge mid-answer.
-        if (isGuideOrigin(event)) {
-          if (typeof event.conversationId === 'string' && event.conversationId) {
-            guideConversationId = event.conversationId
-            invalidate()
-          }
-          break
-        }
         // Legacy `parseChunkToAction` action shape, reconstructed for the
         // callback contract.
         emit('onMetadata', {
@@ -1125,17 +1101,11 @@ export function createChatStreamReducer(
         const requestId = event.requestId
         const approvalType = event.approvalType ?? 'USER'
         const toolCalls = event.toolCalls
-        // Where this card renders is ONE rule, shared with the SSE kernel and
-        // the history replay (`approval-display`) — a Product Guide proposal
-        // that renders inline live must not move on the next page load.
-        const guideOrigin = guideApprovalOrigin(event)
-        const displayInline = (type: string) =>
-          approvalDisplaysInline(event, type, displayApprovalTypes)
 
         if (toolCalls && toolCalls.length > 0) {
           // ── Batch form ──
           const status = (approvalStatuses[requestId] || 'pending') as ChatApprovalStatus
-          if (!displayInline(approvalType)) {
+          if (!displayApprovalTypes.includes(approvalType)) {
             // Escalated: keep batch context locally for replay on result;
             // surface a summary command via the legacy escalation callback.
             const required = toolCalls.find((c) => c.requiresApproval) ?? toolCalls[0]
@@ -1157,15 +1127,7 @@ export function createChatStreamReducer(
           }
           if (batchApprovalsEnabled) {
             const before = accumulator.getSegments().length
-            const segments = accumulator.addApprovalBatch(
-              requestId,
-              approvalType,
-              toolCalls,
-              status,
-              undefined,
-              undefined,
-              guideOrigin,
-            )
+            const segments = accumulator.addApprovalBatch(requestId, approvalType, toolCalls, status)
             applyAccumulated(before, segments)
             break
           }
@@ -1183,8 +1145,6 @@ export function createChatStreamReducer(
               call.toolExplanation,
               approvalType,
               status,
-              undefined,
-              guideOrigin,
             )
           }
           applyAccumulated(before, segments)
@@ -1194,7 +1154,7 @@ export function createChatStreamReducer(
         // ── Single form ──
         const command = event.command ?? ''
         const explanation = event.explanation
-        if (displayInline(approvalType)) {
+        if (displayApprovalTypes.includes(approvalType)) {
           const status = (approvalStatuses[requestId] || 'pending') as ChatApprovalStatus
           const before = accumulator.getSegments().length
           const segments = accumulator.addApprovalRequest(
@@ -1203,10 +1163,6 @@ export function createChatStreamReducer(
             explanation,
             approvalType,
             status,
-            // SSE-shaped cards (a re-streamed Product Guide proposal) carry
-            // their body as structured rows rather than prose.
-            event.fields,
-            guideOrigin,
           )
           applyAccumulated(before, segments)
         } else {
@@ -1751,7 +1707,6 @@ export function createChatStreamReducer(
     streamingPhase = 'idle'
     dialogTokenUsage = null
     liveModel = null
-    guideConversationId = null
     approvalStatuses = {}
     accumulator.reset()
     pendingEscalated.clear()
@@ -1800,7 +1755,6 @@ export function createChatStreamReducer(
     streamingPhase = 'idle'
     dialogTokenUsage = null
     liveModel = null
-    guideConversationId = null
     accumulator.reset()
     pendingEscalated.clear()
     isInStream = false

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

@@ -113,12 +113,6 @@ export interface ApprovalRequestData {
   requestId?: string
   approvalRequestId?: string
   approvalType?: string
-  /** `'guide'` when the card came from a Product Guide frame (see `GuideOrigin`
-   *  in `chat-protocol/events`). Carried onto the segment because hosts route
-   *  and filter approvals by where they came from: mingo lifts its OWN pending
-   *  cards into a sticky footer, and a guide card must stay inline in the turn
-   *  the way it does in the hub's chat. */
-  origin?: 'guide'
 }
 
 export interface ApprovalResultData {
@@ -195,11 +189,6 @@ export interface ApprovalBatchData {
    * batch itself is approved.
    */
   executions?: Record<string, ApprovalBatchExecutionState>
-  /** `'guide'` when the batch came from a Product Guide `approval_batch` frame.
-   *  Same contract and the same reasons as `ApprovalRequestData.origin` — the
-   *  hub groups multiple proposals into one card, and that card resolves
-   *  through the hub exactly like a single one. */
-  origin?: 'guide'
 }
 
 /** Approve/reject handler stamped onto approval segments. MAY resolve a
@@ -345,10 +334,6 @@ export interface ThinkingMessageData extends MessageDataBase {
 export interface GuideMessageData extends MessageDataBase {
   type: 'GUIDE'
   text?: string
-  /** Persisted Product Guide frame (GraphQL `GuideData.payload`, a JSON scalar)
-   *  for rows that carry a card instead of answer text — replayed through the
-   *  live path's `guideFrameEvent`. */
-  payload?: Record<string, unknown>
 }
 
 /** Persisted `ASK` row (GraphQL `AskData`). `text` is the intro sentence, which

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

@@ -61,10 +61,6 @@ export interface ChunkData {
   /** On APPROVAL_RESULT chunks: display name of the user who resolved the request. */
   resolvedByName?: string
   toolCalls?: any[]
-  /** On GUIDE chunks: a Product Guide frame the agent re-streamed verbatim from
-   *  the hub, instead of the answer text `text` carries. Decoded by
-   *  `decodeNatsChunk` through the shared leading-frame table. */
-  payload?: Record<string, unknown>
   modelName?: string
   providerName?: string
   provider?: string

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

@@ -3,12 +3,7 @@
  * Contains types for message parsing, accumulation, and processing
  */
 
-import type {
-  ApprovalRequestField,
-  MessageSegment,
-  PendingToolCallData,
-  ExecutingToolState,
-} from './message.types'
+import type { MessageSegment, PendingToolCallData, ExecutingToolState } from './message.types'
 import type { ChatApprovalStatus, AssistantType } from './chat.types'
 import type { ChunkData } from './network.types'
 
@@ -23,12 +18,6 @@ export interface PendingApproval {
   command: string
   explanation?: string
   approvalType: string
-  /** Structured label/value rows — a Product Guide card is almost entirely
-   *  these, so a path that forgets them renders a bare title. */
-  fields?: ApprovalRequestField[]
-  /** Where the card came from; `'guide'` keeps it inline and routes its
-   *  buttons to the hub (see `ApprovalRequestData.origin`). */
-  origin?: 'guide'
 }
 
 export interface AccumulatorState {

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

@@ -10,7 +10,6 @@
 
 import { describe, it, expect } from 'vitest'
 import { processHistoricalMessagesWithErrors } from '../process-historical-messages'
-import { decodeNatsChunk } from '../../../../chat-protocol/nats-decoder'
 import { createChatStreamReducer } from '../../stream/chat-stream-reducer'
 import type { HistoricalMessage, MessageSegment } from '../../types'
 
@@ -157,94 +156,3 @@ describe('displayApprovalTypes — history vs realtime default divergence', () =
     expect(live.escalated).toHaveLength(0)
   })
 })
-
-/**
- * A Product Guide card must survive a reload UNCHANGED.
- *
- * It arrives as a hub frame the agent re-streams into the dialog, so it is
- * typed by TOOL and resolves through the hub's confirm route — the tier gate
- * these tests are about simply does not apply to it. When the rule lived only
- * in the realtime kernel, the same card rendered inline while streaming and
- * then, on the next page load, was tier-gated: lifted out of its turn into the
- * consumer's sticky pending-approvals envelope, stripped of the `fields` that
- * are its entire body, and stripped of the `origin` that routes its buttons —
- * so clicking Approve hit the agent's endpoint and 404'd.
- */
-describe('Product Guide approvals — history and realtime agree', () => {
-  const guideProposalMessage = (id: string): HistoricalMessage => ({
-    id,
-    createdAt: '2026-07-17T12:00:00Z',
-    owner: { type: 'ASSISTANT' },
-    messageData: [
-      {
-        type: 'GUIDE',
-        payload: {
-          kind: 'approval_request',
-          proposalId: 'prop-1',
-          toolName: 'create_ticket',
-          title: 'Open a support ticket',
-          fields: [{ label: 'Subject', value: 'Agent will not enroll' }],
-        },
-      } as any,
-    ],
-  })
-
-  // The narrowest possible tier list: it excludes the guide's tool name, so a
-  // card that still renders proves the gate was bypassed, not merely satisfied.
-  const NARROW_TIERS = ['CLIENT']
-
-  it('renders inline on reload despite a tier list that excludes it', () => {
-    const { messages, escalatedApprovals } = processHistoricalMessagesWithErrors(
-      [guideProposalMessage('m1')],
-      { displayApprovalTypes: NARROW_TIERS },
-    )
-    const rendered = messages.flatMap((m) => approvalSegments(m.content))
-    expect(rendered).toHaveLength(1)
-    expect(escalatedApprovals.size).toBe(0)
-  })
-
-  it('keeps the card in its own turn, not in the sticky pending-approvals envelope', () => {
-    const { messages } = processHistoricalMessagesWithErrors([guideProposalMessage('m1')], {
-      displayApprovalTypes: NARROW_TIERS,
-    })
-    expect(messages.some((m) => String(m.id).startsWith('pending-approvals-'))).toBe(false)
-    const turn = messages.find((m) => m.id === 'm1')
-    expect(approvalSegments(turn?.content)).toHaveLength(1)
-  })
-
-  it('carries the same fields and origin as the live stream', () => {
-    /** The single card's `data`, narrowed off the segment union. */
-    const cardData = (segments: MessageSegment[]) => {
-      const card = segments.find((s) => s.type === 'approval_request')
-      return card?.type === 'approval_request' ? card.data : undefined
-    }
-
-    const { messages } = processHistoricalMessagesWithErrors([guideProposalMessage('m1')], {
-      displayApprovalTypes: NARROW_TIERS,
-    })
-    const replayed = cardData(messages.flatMap((m) => approvalSegments(m.content)))
-
-    const live = createChatStreamReducer({ transport: 'nats', displayApprovalTypes: NARROW_TIERS })
-    live.apply({ type: 'turn-start' })
-    live.apply(
-      decodeNatsChunk({
-        type: 'GUIDE',
-        payload: {
-          kind: 'approval_request',
-          proposalId: 'prop-1',
-          toolName: 'create_ticket',
-          title: 'Open a support ticket',
-          fields: [{ label: 'Subject', value: 'Agent will not enroll' }],
-        },
-      })!,
-    )
-    const streamed = cardData(live.state.messages.flatMap((m) => approvalSegments(m.segments)))
-
-    // Same card either way — down to the rows that ARE its body, and the marker
-    // that decides which backend its buttons talk to.
-    expect(replayed).toEqual(streamed)
-    expect(replayed?.origin).toBe('guide')
-    expect(replayed?.approvalType).toBe('create_ticket')
-    expect(replayed?.fields).toEqual([{ label: 'Subject', value: 'Agent will not enroll' }])
-  })
-})

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

@@ -14,15 +14,6 @@ export {
   type AccumulatorCallbacks,
 } from './message-segment-accumulator'
 
-// Where an approval card renders — one rule for both live kernels, the history
-// replay, and hosts that sort cards between their own footer and the flow.
-export {
-  isGuideApproval,
-  guideApprovalOrigin,
-  approvalDisplaysInline,
-  isGuideApprovalSegment,
-} from './approval-display'
-
 // Historical message processing
 export {
   processHistoricalMessages,

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

@@ -12,7 +12,6 @@ import type {
   AskOptionData,
   MessageSegment,
   ToolExecutionSegment,
-  ApprovalRequestField,
   ApprovalRequestSegment,
   ApprovalBatchSegment,
   ApprovalBatchExecutionState,
@@ -325,55 +324,23 @@ export class MessageSegmentAccumulator {
     command: string,
     explanation: string | undefined,
     approvalType: string,
-    status: ChatApprovalStatus = 'pending',
-    /** Structured label/value rows. The card prefers them over `explanation`
-     *  (see `ApprovalRequestData.fields`). Optional because the agent's own
-     *  approvals carry prose; a Product Guide card is almost entirely fields —
-     *  dropping them here left it as a bare title. */
-    fields?: ApprovalRequestField[],
-    /** Where the card came from; `'guide'` keeps it inline (see
-     *  `ApprovalRequestData.origin`). */
-    origin?: 'guide'
+    status: ChatApprovalStatus = 'pending'
   ): MessageSegment[] {
-    this.segments.push(
-      this.buildApprovalRequestSegment(
-        requestId,
-        { command, explanation, approvalType, fields, origin },
-        status,
-      ),
-    )
-    return this.getSegments()
-  }
-
-  /**
-   * Build one approval-request segment — THE constructor for this segment type.
-   *
-   * Three paths produce these: `addApprovalRequest` (live stream and replay),
-   * `flushPendingApprovals` (tracked-but-unresolved after a history replay) and
-   * `processApprovalResult` (a result arriving for a tracked request). They used
-   * to hand-write the object each, which is how `fields` and `origin` reached
-   * the card down one path and not the others — the same proposal rendering as a
-   * bare title, or losing the marker that routes its buttons to the hub.
-   */
-  private buildApprovalRequestSegment(
-    requestId: string,
-    approval: PendingApproval,
-    status: ChatApprovalStatus,
-  ): ApprovalRequestSegment {
-    return {
+    const segment: ApprovalRequestSegment = {
       type: 'approval_request',
       data: {
-        command: approval.command,
-        explanation: approval.explanation,
+        command,
+        explanation,
         requestId,
-        approvalType: approval.approvalType,
-        ...(approval.fields && approval.fields.length > 0 ? { fields: approval.fields } : {}),
-        ...(approval.origin ? { origin: approval.origin } : {}),
+        approvalType,
       },
       status,
       onApprove: this.callbacks.onApprove,
       onReject: this.callbacks.onReject,
     }
+
+    this.segments.push(segment)
+    return this.getSegments()
   }
 
   /**
@@ -396,9 +363,6 @@ export class MessageSegmentAccumulator {
     status: ChatApprovalStatus = 'pending',
     executions?: Record<string, ApprovalBatchExecutionState>,
     resolvedByName?: string | null,
-    /** Where the batch came from; `'guide'` keeps it inline and routes it to
-     *  the hub, exactly as for a single card (see `ApprovalBatchData.origin`). */
-    origin?: 'guide',
   ): MessageSegment[] {
     const existingIndex = this.segments.findIndex(
       (s): s is ApprovalBatchSegment =>
@@ -408,9 +372,6 @@ export class MessageSegmentAccumulator {
     if (existingIndex !== -1) {
       const existing = this.segments[existingIndex] as ApprovalBatchSegment
       const mergedExecutions = executions ?? existing.data.executions
-      // An upsert must not strip the marker: the flip to `approved` comes from
-      // a later event that carries no origin of its own.
-      const mergedOrigin = origin ?? existing.data.origin
       this.segments[existingIndex] = {
         ...existing,
         data: {
@@ -418,7 +379,6 @@ export class MessageSegmentAccumulator {
           approvalType,
           toolCalls,
           ...(mergedExecutions ? { executions: mergedExecutions } : {}),
-          ...(mergedOrigin ? { origin: mergedOrigin } : {}),
         },
         status,
         resolvedByName: resolvedByName ?? existing.resolvedByName,
@@ -435,7 +395,6 @@ export class MessageSegmentAccumulator {
         approvalType,
         toolCalls,
         ...(executions ? { executions } : {}),
-        ...(origin ? { origin } : {}),
       },
       status,
       resolvedByName,
@@ -458,17 +417,20 @@ export class MessageSegmentAccumulator {
   ): { segment: ApprovalRequestSegment; pendingData: PendingApproval | null } | null {
     const pendingApproval = this.pendingApprovals.get(requestId)
     const status: ChatApprovalStatus = approved ? 'approved' : 'rejected'
-
-    const segment = this.buildApprovalRequestSegment(
-      requestId,
-      {
-        ...pendingApproval,
+    
+    const segment: ApprovalRequestSegment = {
+      type: 'approval_request',
+      data: {
         command: pendingApproval?.command || '',
+        explanation: pendingApproval?.explanation,
+        requestId,
         approvalType: pendingApproval?.approvalType || approvalType,
       },
       status,
-    )
-
+      onApprove: this.callbacks.onApprove,
+      onReject: this.callbacks.onReject,
+    }
+    
     this.segments.push(segment)
     
     if (pendingApproval) {
@@ -576,11 +538,22 @@ export class MessageSegmentAccumulator {
    */
   flushPendingApprovals(): ApprovalRequestSegment[] {
     const segments: ApprovalRequestSegment[] = []
-
+    
     this.pendingApprovals.forEach((approval, requestId) => {
-      segments.push(this.buildApprovalRequestSegment(requestId, approval, 'pending'))
+      segments.push({
+        type: 'approval_request',
+        data: {
+          command: approval.command,
+          explanation: approval.explanation,
+          requestId,
+          approvalType: approval.approvalType,
+        },
+        status: 'pending',
+        onApprove: this.callbacks.onApprove,
+        onReject: this.callbacks.onReject,
+      })
     })
-
+    
     return segments
   }
 
@@ -654,8 +627,6 @@ export class MessageSegmentAccumulator {
             data.explanation,
             data.approvalType || '',
             status,
-            data.fields,
-            data.origin,
           )
           break
         }
@@ -668,7 +639,6 @@ export class MessageSegmentAccumulator {
             status,
             data.executions,
             resolvedByName,
-            data.origin,
           )
           break
         }

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

@@ -40,8 +40,7 @@ import {
 import { ESCALATION_STATE, escalationResolvedStatus, type ChatStreamEvent } from '../../../chat-protocol/events'
 // One normalizer for ask rows, shared with the live decoder — history and the
 // stream must agree on which options are usable.
-import { guideFrameEvent, normalizeAskOptions } from '../../../chat-protocol/nats-decoder'
-import { approvalDisplaysInline, guideApprovalOrigin } from './approval-display'
+import { normalizeAskOptions } from '../../../chat-protocol/nats-decoder'
 import { MessageSegmentAccumulator, createMessageSegmentAccumulator } from './message-segment-accumulator'
 import { applyApprovalStatusToSegment } from '../stream/message-mutations'
 import { getCommandText } from './tool-call-helpers'
@@ -116,21 +115,11 @@ export function decodeHistoricalMessageData(data: MessageData): ChatStreamEvent
       }
       return null
 
-    // Two persisted shapes, mirroring the live `GUIDE` chunk: the answer body
-    // (`text`) and a Product Guide frame the agent re-streamed (`payload`,
-    // persisted so a card survives a reload). Decoded through the SAME
-    // `guideFrameEvent` the live path uses — a second mapping here would let
-    // history and realtime disagree about the same bytes.
-    case MESSAGE_TYPE.GUIDE: {
+    case MESSAGE_TYPE.GUIDE:
       if ('text' in data && data.text) {
         return { type: 'guide-delta', text: data.text }
       }
-      const payload = 'payload' in data ? data.payload : undefined
-      if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
-        return guideFrameEvent(payload as Record<string, unknown>)
-      }
       return null
-    }
 
     // Same completeness gate as the live decoder (`decodeNatsChunk`): a
     // persisted row without a question or without options is not a card the
@@ -372,24 +361,12 @@ function applyHistoryEvent(
       const approvalType = event.approvalType || 'CLIENT'
       const toolCalls = event.toolCalls as PendingToolCallData[] | undefined
       const isBatch = !!toolCalls && toolCalls.length > 0
-      // Same rule the live kernels use — a card must not change where it
-      // renders (or which backend its buttons hit) just because the page was
-      // reloaded and it came back through history instead of the stream.
-      const guideOrigin = guideApprovalOrigin(event)
 
-      if (approvalDisplaysInline(event, approvalType, displayApprovalTypes)) {
+      if (!displayApprovalTypes || displayApprovalTypes.includes(approvalType)) {
         if (isBatch) {
           const status = (approvalStatuses[event.requestId] as ChatApprovalStatus) || 'pending'
           if (batchApprovalsEnabled) {
-            accumulator.addApprovalBatch(
-              event.requestId,
-              approvalType,
-              toolCalls!,
-              status,
-              undefined,
-              undefined,
-              guideOrigin,
-            )
+            accumulator.addApprovalBatch(event.requestId, approvalType, toolCalls!, status)
           } else {
             // Flag OFF — unfold batch into N legacy approval cards (same id).
             for (const call of toolCalls!) {
@@ -400,8 +377,6 @@ function applyHistoryEvent(
                 call.toolExplanation,
                 approvalType,
                 status,
-                undefined,
-                guideOrigin,
               )
             }
           }
@@ -414,28 +389,19 @@ function applyHistoryEvent(
           // sticky card on every history re-process. Mirror the batch path
           // and honor `approvalStatuses`.
           const resolvedStatus = approvalStatuses[event.requestId] as ChatApprovalStatus | undefined
-          const isResolved = resolvedStatus === 'approved' || resolvedStatus === 'rejected'
-          // A guide card is added inline even while pending. The tracked path
-          // below ends in `flushPendingApprovals`, whose segments the consumer
-          // lifts into a sticky footer — that is the treatment for the
-          // consumer's OWN approvals, and it is not how the hub's chat renders
-          // a proposal (nor where its preamble expects it).
-          if (guideOrigin || isResolved) {
+          if (resolvedStatus === 'approved' || resolvedStatus === 'rejected') {
             accumulator.addApprovalRequest(
               event.requestId,
               event.command || '',
               event.explanation,
               approvalType,
-              resolvedStatus ?? 'pending',
-              event.fields,
-              guideOrigin,
+              resolvedStatus,
             )
           } else {
             accumulator.trackApprovalRequest(event.requestId, {
               command: event.command || '',
               explanation: event.explanation,
               approvalType,
-              fields: event.fields,
             })
           }
         }