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

package/src/components/chat/hooks/.use-nats-chat-adapter.md

@@ -1,52 +1,71 @@
-<!-- source-hash: 6c5780e92306ea381bac35aaf97c435f -->
-Provides the NATS/Mingo-mode transport adapter for the unified chat surface, implementing the `UnifiedChatState` contract so the `useChat({ mode })` dispatcher can switch between NATS and SSE adapters without shell-side branching.
+<!-- source-hash: 3fbde71f6e5fc7f9b4576423ebdb08e2 -->
+Thin wrapper that wires together NATS subscriptions, real-time chunk processing, and dialog management into a single `UnifiedChatState` object for the Mingo/NATS transport mode of the unified chat surface.
 
 ## Key Components
 
 ### `UseNatsChatAdapterConfig`
-Consumer-supplied configuration interface covering:
-- `dialogId` — active conversation identifier
-- `getNatsWsUrl` — factory returning the NATS WebSocket URL
-- `publishUserMessage` — consumer-owned send callback (HTTP POST or NATS publish)
-- `fetchChunks` — optional historical chunk fetcher for catchup
-- `clientConfig` — optional NATS auth credentials
-- `enableThinking` / `batchApprovalsEnabled` — processor feature flags
+Primary configuration interface with two operational modes:
+- **Bare-transport mode** — caller supplies `dialogId` explicitly and owns dialog lifecycle (original v0 API, used by Tauri Fae Chat)
+- **Managed-dialog mode** — caller supplies `fetchDialogs` and related callbacks; the adapter owns dialog state, pagination, and history
 
-### `UseNatsChatAdapterOptions`
-- `active` — gates the live subscription; keeps message state alive while the mode is hidden
+### Core Config Fields
 
-### `useNatsChatAdapter(config, options)`
-Main hook. Composes three internal hooks:
+| Field | Required | Description |
+|-------|----------|-------------|
+| `getNatsWsUrl` | ✅ | Returns the NATS WebSocket URL or `null` to suspend |
+| `publishUserMessage` | ✅ | Consumer-owned send callback (HTTP POST or NATS publish) |
+| `dialogId` | ❌ | Explicit dialog ID (bare-transport mode) |
+| `fetchDialogs` | ❌ | Enables managed-dialog mode with sidebar support |
+| `fetchDialogMessages` | ❌ | Populates history on dialog switch |
+| `topics` | ❌ | NATS subject suffixes to tail (default: `['message']`) |
+
+### Supporting Interfaces
+
+- **`FetchDialogsParams`** / **`FetchDialogsResult`** — paginated dialog list with cursor-based pagination
+- **`FetchDialogMessagesParams`** / **`FetchDialogMessagesResult`** — paginated message history with optional `tokenUsage`
+
+### Composition Stack
 
 ```text
-useNatsDialogSubscription  →  live NATS event tail
-         ↓
-decodeNatsChunk + reducer  →  chunk → ChatStreamEvent → state
-         ↓
-useChunkCatchup            →  back-fills missed chunks on reconnect/activation
+useNatsDialogSubscription  → live NATS event tail
+        ↓
+useRealtimeChunkProcessor  → chunk → MessageSegment[]
+        ↓
+useChunkCatchup            → back-fills missed chunks on reconnect
+        ↓
+config.publishUserMessage  → consumer-owned send (HTTP/NATS)
 ```
 
-Returns a full `UnifiedChatState` object including `messages`, `isLoading`, `streamingPhase`, `sendMessage`, `stopMessage`, and `clearMessages`.
-
 ## Usage Example
 
 ```typescript
-const chatState = useNatsChatAdapter(
-  {
-    dialogId: 'dialog-abc123',
-    getNatsWsUrl: () => `wss://nats.example.com`,
-    publishUserMessage: async (text, { dialogId }) => {
-      await fetch('/api/chat', {
-        method: 'POST',
-        body: JSON.stringify({ text, dialogId }),
-      })
-    },
-    fetchChunks: ({ dialogId, after }) =>
-      fetch(`/api/chunks?dialogId=${dialogId}&after=${after}`).then(r => r.json()),
-    batchApprovalsEnabled: true,
+// Bare-transport mode (v0 — Tauri Fae Chat)
+const chatState = useNatsChatAdapter({
+  dialogId: activeDialogId,
+  getNatsWsUrl: () => `wss://nats.example.com`,
+  publishUserMessage: async (text, { dialogId }) => {
+    await fetch(`/api/chat/${dialogId}/message`, {
+      method: 'POST',
+      body: JSON.stringify({ text }),
+    })
   },
-  { active: isNatsModeVisible },
-)
+  topics: ['admin-message'],
+})
+
+// Managed-dialog mode (openframe-frontend / EmbeddableChat)
+const chatState = useNatsChatAdapter({
+  getNatsWsUrl: () => natsUrl,
+  publishUserMessage: sendMessage,
+  fetchDialogs: async ({ cursor, limit }) => api.listDialogs({ cursor, limit }),
+  fetchDialogMessages: async ({ dialogId, cursor }) =>
+    api.getMessages(dialogId, { cursor }),
+  createDialog: () => api.createDialog(),
+  deleteDialog: (id) => api.deleteDialog(id),
+  approveRequest: (requestId) => api.approve(requestId),
+  rejectRequest: (requestId, reason) => api.reject(requestId, reason),
+})
 ```
 
-> **Note:** `publishUserMessage` is intentionally consumer-owned — the adapter only handles optimistic UI updates and phase transitions; the actual transport is wired externally.
+> **Note:** Set `topics: ['admin-message']` for Mingo/admin deployments. The default `'message'` topic is for Fae client-chat. Mismatched topics cause the assistant to hang in the `thinking` phase indefinitely.
+
+**Source:** [`use-nats-chat-adapter.ts`](https://github.com/flamingo-stack/openframe-oss-lib/blob/main/use-nats-chat-adapter.ts)

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

@@ -0,0 +1,77 @@
+<!-- source-hash: 681c783784fdc89f0c86eb3e539c482b -->
+Processes real-time NATS streaming chunks into structured message segments, managing streaming state, approval flows, direct-mode barriers, and tool execution events for AI assistant chat interfaces.
+
+## Key Components
+
+### `useRealtimeChunkProcessor(options)`
+
+Main hook export. Accepts `UseRealtimeChunkProcessorOptions` and returns `UseRealtimeChunkProcessorReturn`.
+
+**Options:**
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `callbacks` | `object` | required | Event handlers (`onSegmentsUpdate`, `onStreamStart`, `onStreamEnd`, `onApprove`, `onReject`, etc.) |
+| `displayApprovalTypes` | `string[]` | `['CLIENT']` | Approval types rendered inline; others are escalated |
+| `approvalStatuses` | `object` | `{}` | Current status map keyed by `requestId` |
+| `initialState` | `object` | — | Hydrates accumulator for resumed dialogs |
+| `batchApprovalsEnabled` | `boolean` | `true` | Renders batch approvals as a single card; `false` unfolds into individual cards |
+| `isDirectMode` | `boolean` | `false` | Activates the direct-mode barrier, dropping AI assistant chunks |
+
+### Internal Refs
+
+| Ref | Purpose |
+|---|---|
+| `accumulatorRef` | `MessageSegmentAccumulator` instance managing segment state |
+| `isInStreamRef` | Tracks open/closed stream window (`MESSAGE_START` → `MESSAGE_END`) |
+| `hasEverStreamedRef` | Distinguishes cold-start vs. post-stream continuation for append mode |
+| `directModeFlagRef` / `sawDirectMessageRef` | Direct-mode barrier gate |
+| `directTeardownFiredRef` | One-shot guard: ensures teardown fires exactly once on barrier entry |
+| `pendingEscalatedRef` | Map of escalated approval requests not shown inline |
+
+### Supported Chunk Actions
+
+| Action | Behavior |
+|---|---|
+| `message_start` / `message_end` | Opens/closes stream, resets accumulator |
+| `text` / `thinking` | Appends to accumulator; uses append-mode after `MESSAGE_END` |
+| `tool_execution` | Routes in-stream to accumulator; post-stream to `onToolExecuted` callback |
+| `approval_request` | Inline or escalated based on `displayApprovalTypes` |
+| `approval_batch` | Single batch card, legacy card fan-out, or escalated |
+| `metadata` | Forwarded directly to `onMetadata` |
+| `direct_message` | Activates direct-mode barrier |
+
+## Usage Example
+
+```typescript
+const { processChunk } = useRealtimeChunkProcessor({
+  callbacks: {
+    onSegmentsUpdate: (segments, meta) => setSegments(segments),
+    onStreamStart: () => setIsStreaming(true),
+    onStreamEnd: () => setIsStreaming(false),
+    onApprove: (requestId) => approveAction(requestId),
+    onReject: (requestId) => rejectAction(requestId),
+    onEscalatedApproval: (requestId, data) => notifyAdmin(requestId, data),
+    onToolExecuted: (segment) => updateToolCard(segment),
+    onAgentBusy: () => showTypingIndicator(),
+    onMetadata: (meta) => handleMetadata(meta),
+  },
+  displayApprovalTypes: ['CLIENT'],
+  batchApprovalsEnabled: true,
+  isDirectMode: false,
+  approvalStatuses: { 'req-123': 'approved' },
+})
+
+// Wire to your NATS subscription
+natsSubscription.onMessage((rawChunk) => {
+  processChunk(rawChunk)
+})
+```
+
+## Direct-Mode Barrier
+
+When `isDirectMode` is `true` or a `direct_message` chunk arrives, the hook drops all subsequent AI-assistant chunks (everything not in `DIRECT_MODE_ALLOWED`). Teardown fires exactly once — clearing the typing indicator, composer lock, and in-progress bubble — even if no stream is currently open (e.g., during post-approval tool execution).
+
+## Source
+
+[`use-realtime-chunk-processor.ts`](https://github.com/flamingo-stack/openframe-oss-lib/blob/main/use-realtime-chunk-processor.ts)

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

@@ -5,6 +5,7 @@ export * from './use-collapsible'
 export * from './use-scripted-stream'
 export * from './use-jetstream-dialog-subscription'
 export * from './use-nats-dialog-subscription'
+export * from './use-realtime-chunk-processor'
 
 // Chat hooks migrated from hub `hooks/*` (Task #7).
 export * from './use-slash-commands'

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

@@ -1,13 +1,5 @@
 'use client'
 
-/**
- * @deprecated Phase 3 of the chat unification moved the SSE adapter off this
- * hook — its trailing-assistant merge + `decision_resolved` receipt path now
- * live in `../stream/chat-stream-reducer` (transport: 'sse'). No lib-internal
- * code consumes `useChat`/`useSSE` anymore; they remain exported for external
- * consumers until Phase 4 migrates them, then get deleted (Phase 6).
- */
-
 import { useState, useCallback, useEffect, useRef } from 'react'
 import { useSSE, type StreamFn, type StreamFnExtraOptions } from './use-sse'
 import type {