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

package/dist/components/chat/stream/chat-stream-reducer.d.ts

@@ -0,0 +1,380 @@
+/**
+ * createChatStreamReducer — THE master chat-stream reader (Phase 3 of the
+ * chat unification). One accumulation path for every event source:
+ *
+ *   SSE bytes  → createSseFrameDecoder ─┐
+ *   NATS chunk → decodeNatsChunk       ─┼→ ChatStreamEvent → reducer.apply()
+ *   history    → decodeHistoricalMessageData (per-item vocabulary) →
+ *                envelope grouping → reducer.initializeWithState()
+ *
+ * The reducer absorbs, verbatim, the semantics that used to be spread over
+ * three layers:
+ *   - `MessageSegmentAccumulator` stays as the internal per-turn segment
+ *     kernel (instantiated here — its goldens remain valid);
+ *   - the deleted `useRealtimeChunkProcessor`'s switch (in-stream vs post-END
+ *     routing, agent-busy outside a message window, escalated approvals,
+ *     compaction upsert, direct-mode barrier) — surfaced as
+ *     `ChatReducerEffect`s for consumers that want the callback contract;
+ *   - `useNatsChatAdapter`'s message-mutation callbacks (trailing-assistant
+ *     replace/append, compaction upsert, cross-message tool merge, approval
+ *     flip, participant dedup) — now the reducer's own state transitions via
+ *     `./message-mutations`;
+ *   - `useSseChatAdapter`/`useChat`'s SSE turn kernel (cumulative text
+ *     replace, front-inserted thinking, approval card, `decision_resolved`
+ *     receipt + cardRef stamping, sendIdx-keyed sources/refs/meta maps).
+ *
+ * Idempotency:
+ *   - events whose `seq` ≤ the last applied seq are dropped (per instance);
+ *   - participant rows additionally dedup via a one-shot optimistic-echo
+ *     list and a short same-author content window (seq-less transports);
+ *   - value-level no-op merges return prior references (see
+ *     `message-mutations.ts`).
+ *
+ * TRANSPORT ORDERING ASSUMPTION (the seq gate, see `apply()`): every
+ * transport feeding this reducer is AT-LEAST-ONCE and IN-ORDER. JetStream
+ * redelivers (hence the gate) but never reorders within a stream, and the
+ * catchup back-fill replays a monotonically increasing range. So `seq <=
+ * lastAppliedSeq` means "already applied", and dropping is correct.
+ * A genuinely out-of-order arrival (seq 5 then 4) would be discarded
+ * PERMANENTLY — accepted deliberately: no transport here reorders, and an
+ * out-of-order buffer would add latency + unbounded state to guard against
+ * a case that cannot occur. If a reordering transport is ever added, this
+ * gate is the place that must change (do not paper over it downstream).
+ *
+ * `resolvePendingApprovalForExecution` (the accumulator's implicit
+ * approve-on-execution) is reachable ONLY on `transport: 'nats'` — the SSE
+ * kernel never routes tool executions through the accumulator.
+ *
+ * PURE + framework-free: no React, no timers, no network. Side effects the
+ * UI needs (approve/reject POSTs) enter as opaque callbacks stamped onto
+ * approval segments.
+ */
+import { type AccumulatorCallbacks } from '../utils/message-segment-accumulator';
+import { type ScrollAnchor } from '../utils/scroll-anchor';
+import type { ChatApprovalStatus, MessageSegment, PendingToolCallData, ToolExecutionSegment, ExecutingToolState } from '../types';
+import type { PendingApproval } from '../types/processing.types';
+import type { DialogTokenUsage, StreamingPhase, UnifiedChatMessage, UnifiedUsageBreakdown } from '../types/unified-chat-state.types';
+import { type ChatStreamEvent } from '../../../chat-protocol/events';
+import type { ChatRef } from '../chat-ref.types';
+/** Per-turn metadata extracted from the streamed metadata/usage frames
+ *  (SSE transport). Canonical home — `use-sse-chat-adapter` re-exports it. */
+export interface ChatTurnMeta {
+    provider: string | null;
+    modelLabel: string | null;
+    contextWindowMaxTokens: number | null;
+    /** Input tokens (from usage:start). Includes cached tokens. */
+    inputTokens: number | null;
+    /** Output tokens (from the trailing usage frame). */
+    outputTokens: number | null;
+    /** Cache hit % (read / total-input × 100). Only known after stream end. */
+    cacheHitRatePct: number | null;
+    /** Cross-call usage breakdown extracted from the trailing usage frame. */
+    breakdown: UnifiedUsageBreakdown | null;
+    /** Per-message viewport-positioning hint. */
+    scrollAnchor: ScrollAnchor | null;
+    routedComplexity: string | null;
+    routedThinkingBudget: number | null;
+}
+/** Single source of truth for a fresh `ChatTurnMeta` row. */
+export declare function createEmptyTurnMeta(): ChatTurnMeta;
+/** SSE per-send maps, keyed by the send counter (`sendIdx`). Each user send
+ *  produces ONE server-side refs/sources entry but can fan out to MULTIPLE
+ *  assistant messages client-side — the adapter maps every following
+ *  assistant message back to its send's entry. */
+export interface ChatTurnMetaState {
+    meta: Map<number, ChatTurnMeta>;
+    sources: Map<number, unknown[]>;
+    refs: Map<number, Record<string, ChatRef>>;
+    sendCount: number;
+}
+export interface ChatReducerState {
+    messages: UnifiedChatMessage[];
+    streamingPhase: StreamingPhase;
+    turnMeta: ChatTurnMetaState;
+    dialogTokenUsage?: DialogTokenUsage | null;
+    liveModel?: {
+        provider: string | null;
+        modelLabel: string | null;
+        contextWindowMaxTokens: number | null;
+    } | null;
+    approvalStatuses: Record<string, ChatApprovalStatus>;
+}
+/** Escalated-approval bookkeeping entry (mirrors the legacy processor). */
+export interface EscalatedApprovalData {
+    command: string;
+    explanation?: string;
+    approvalType: string;
+    toolCalls?: PendingToolCallData[];
+}
+/**
+ * Callback-visible effect produced by `apply()`. Names + args mirror the
+ * legacy `RealtimeChunkCallbacks` contract 1:1 — the contract the deleted
+ * `useRealtimeChunkProcessor` wrapper exposed, now pinned directly by
+ * `__tests__/chat-stream-reducer-golden.test.ts`.
+ *
+ * `segments-after-approval-result` is the one conditional emission: the
+ * legacy processor emitted a cumulative `onSegmentsUpdate` for a
+ * non-escalated APPROVAL_RESULT only when the consumer had NOT wired
+ * `onApprovalResolved` — the effect sink resolves that at dispatch time.
+ */
+export interface ChatReducerEffect {
+    name: 'onStreamStart' | 'onStreamEnd' | 'onMetadata' | 'onSegmentsUpdate' | 'onError' | 'onUserMessage' | 'onTokenUsage' | 'onDirectMessage' | 'onSystemMessage' | 'onEscalatedApproval' | 'onEscalatedApprovalResult' | 'onApprovalResolved' | 'onToolExecuted' | 'onAgentBusy' | 'onDialogClosed' | 'segments-after-approval-result';
+    args: unknown[];
+}
+export interface ChatStreamReducerOptions {
+    /** Which transport's turn kernel drives `apply()`. Default `'nats'`. */
+    transport?: 'sse' | 'nats';
+    /** Seed for the approval-status map (request-id → status). */
+    approvalStatuses?: Record<string, ChatApprovalStatus>;
+    /** Batch APPROVAL_REQUESTs render as one card (default true) or unfold. */
+    batchApprovalsEnabled?: boolean;
+    /** Approval types displayed inline; others escalate. Default ['CLIENT']. */
+    displayApprovalTypes?: string[];
+    /** Opaque approve/reject handlers stamped onto approval segments. */
+    callbacks?: AccumulatorCallbacks;
+    /** Engage the direct-mode barrier optimistically (host-known takeover). */
+    isDirectMode?: boolean;
+    /**
+     * Legacy-processor parity knob: post-MESSAGE_END tool chunks route
+     * cross-message (`onToolExecuted` effect + `applyToolExecutionToMessages`)
+     * only when the consumer wired the cross-message updater; otherwise they
+     * fall through the accumulator like the pre-callback code path. Default
+     * true (both first-party adapters wire it).
+     */
+    crossMessageToolRouting?: boolean;
+    /** Effect sink for callback-contract consumers (compat wrapper). */
+    onEffect?: (effect: ChatReducerEffect) => void;
+    /** Notified after every state mutation (the dialog store wires this). */
+    onChange?: () => void;
+    /**
+     * Whether an ADMIN-authored `MESSAGE_REQUEST` may be consumed as OUR OWN
+     * optimistic echo (see `pushOptimisticSend`). Default `false`.
+     *
+     * Who the local operator is decides this, and it differs per host:
+     *  - Hub website chat / ticket CLIENT side: the local user is NEVER the
+     *    admin, so an ADMIN-authored inbound row is a technician's reply and
+     *    must ALWAYS render. Consuming it as an echo would silently delete a
+     *    real message whenever its text happened to match ours. → `false`.
+     *  - OpenFrame product app (Mingo + ticket ADMIN side): the operator IS
+     *    the admin, so their own sends echo back as ADMIN and MUST be
+     *    deduped, or every message renders twice. → `true`.
+     *
+     * Only ever applies to text the host itself registered via
+     * `pushOptimisticSend`, so enabling it cannot drop a message the host
+     * did not just send.
+     */
+    ownEchoIncludesAdmin?: boolean;
+    /**
+     * The LOCAL user's id, either as a value or as a GETTER resolved at event
+     * time. When it resolves to a value, an inbound `MESSAGE_REQUEST` that
+     * DECLARES a different author (`event.userId !== selfUserId`) may not be
+     * consumed as our own optimistic echo.
+     *
+     * Without it the echo list matches on RAW TEXT alone, which on a shared
+     * ADMIN side (two technicians in one ticket, `ownEchoIncludesAdmin: true`)
+     * can silently delete a colleague's message: if OUR send never echoes back,
+     * its entry stays armed and the next identical text from anyone — canned
+     * replies like "ok" / "done" / "on it" make this routine — is swallowed.
+     *
+     * The guard FAILS OPEN, deliberately: a row that carries NO `userId` is not
+     * "someone else's", it is UNATTRIBUTED, and rejecting it would disable
+     * dedup entirely (→ every send rendered twice) on any transport whose
+     * decoder does not surface the author id. Such a row falls back to the
+     * text + `OWN_ECHO_TTL_MS` behaviour instead, and a one-shot `console.warn`
+     * makes the missing id observable.
+     *
+     * Pass a FUNCTION whenever the id can change or arrive late (auth
+     * rehydration, logout / login-as-another-user without a reload): reducers
+     * are retained for the store's lifetime, so a value captured at creation
+     * time can go stale and silently disable the guard.
+     */
+    selfUserId?: string | (() => string | undefined);
+}
+/**
+ * How long an un-consumed optimistic-echo entry stays armed **on the
+ * UNATTRIBUTED path**. Long enough to cover any realistic send → server-echo
+ * round trip, short enough that a send whose echo never lands cannot swallow
+ * an unrelated identical message later in the conversation.
+ *
+ * A row that is DECLARED ours (`selfUserId` set and `event.userId ===
+ * selfUserId`) gets the LONGER `OWN_ECHO_AUTHOR_TTL_MS` instead — see there.
+ */
+export declare const OWN_ECHO_TTL_MS = 30000;
+/**
+ * How long an un-consumed entry stays armed on the AUTHOR-MATCHED path
+ * (`selfUserId` set, inbound row declares the same author).
+ *
+ * The author check rules out CROSS-technician theft, but NOT the same user on
+ * a second tab or device: a row THIS tab did not originate looks exactly like
+ * an author-matched echo. So the entry still needs an upper bound — without
+ * one, a send whose echo never lands (dropped frame, backend text
+ * normalization, reconnect gap) leaves the entry armed for the reducer's
+ * whole lifetime, and the next identical text from the same user on ANOTHER
+ * tab is silently swallowed. With `MAX_PENDING_ECHOES` armed slots and canned
+ * replies ("ok", "done", "on it") being exactly the recurring strings, that is
+ * a routine message-LOSS bug, strictly worse than the duplicate row it trades
+ * against.
+ *
+ * Ten minutes is the bound: generously longer than the slow echo the author
+ * path exists to protect (a JetStream catch-up replay after a network gap
+ * arrives long after the send, and its rows carry `seq`, so the seq-less
+ * content-dedup fallback cannot rescue it), and far shorter than the
+ * "same text again an hour later" window in which a stale entry does damage.
+ *
+ * It is a BACKSTOP, not the usual bound: `turn-end` disarms entries much
+ * sooner (see `purgeEchoesAtTurnEnd`). The ten minutes only ever apply to a
+ * dialog that never reports a turn boundary at all.
+ */
+export declare const OWN_ECHO_AUTHOR_TTL_MS: number;
+/** One armed optimistic-echo entry: the sent text and the wall-clock ms it was
+ *  armed at. Exported because the LRU-eviction round trip PARKS these (see
+ *  `getPendingEchoes` / `InitializeExtras.pendingEchoes`). */
+export interface PendingEcho {
+    text: string;
+    at: number;
+}
+export interface InitializeExtras {
+    existingSegments?: MessageSegment[];
+    pendingApprovals?: Map<string, PendingApproval>;
+    executingTools?: Map<string, ExecutingToolState>;
+    escalatedApprovals?: Map<string, EscalatedApprovalData>;
+    /**
+     * Approval statuses PARKED from a previous instance of this key (LRU
+     * eviction hands them to `onEvict`). Merged with the same state-monotonic
+     * precedence as `mergeApprovalStatuses` — a resolved approval must not come
+     * back as actionable, which is exactly why `resetForDialogSwitch` preserves
+     * this map rather than clearing it.
+     */
+    approvalStatuses?: Record<string, ChatApprovalStatus>;
+    /**
+     * Seq cursor PARKED from a previous instance of this key. A recreated
+     * reducer starts at `-Infinity`, so a host that replays from its own cursor
+     * would re-apply already-applied events; restoring the parked value keeps
+     * `apply()`'s idempotency gate intact across an eviction. Only ever moves
+     * the gate FORWARD (a lower value is ignored).
+     */
+    lastAppliedSeq?: number;
+    /**
+     * Armed optimistic-echo entries PARKED from a previous instance of this key.
+     * Without them, a key LRU-evicted between `pushOptimisticSend` and its
+     * `MESSAGE_REQUEST` echo leaves the replacement reducer with nothing armed,
+     * so the echo renders a DUPLICATE user bubble. Entries already past
+     * `OWN_ECHO_AUTHOR_TTL_MS` are dropped on restore (an expired entry could
+     * only swallow an unrelated identical message), and the list is capped at
+     * `MAX_PENDING_ECHOES` exactly as the live path is.
+     */
+    pendingEchoes?: readonly PendingEcho[];
+    /**
+     * Whether the restored thread is a RESUMED dialog (a `MESSAGE_START` already
+     * fired server-side), which makes post-stream continuation chunks append
+     * into the existing bubble instead of taking the cold-start cumulative path.
+     * Defaults to "the restored thread is non-empty" — an eviction restore of a
+     * key that never streamed must NOT claim it did, or a cold text-delta with
+     * no preceding `turn-start` appends into a bubble that was never spawned.
+     * Pass explicitly only to override that derivation.
+     */
+    resumed?: boolean;
+    /**
+     * Whether the restored tail means the AGENT IS STILL WORKING — as opposed to
+     * blocked on the user. Raises an `idle` reducer to `thinking` on restore
+     * (same rule as a live `onAgentBusy`: an open stream keeps the phase), which
+     * is what puts the activity indicator back.
+     *
+     * Nothing on the wire restores this: the phase machine is driven by events,
+     * and a run's EXECUTING chunk is long past by the time a reload happens while
+     * its EXECUTED one may be minutes away. Derived once by
+     * `extractIncompleteMessageState` so every host agrees on the distinction —
+     * a PENDING approval is the opposite state and must NOT spin.
+     */
+    agentBusy?: boolean;
+}
+export interface BeginSseSendOptions {
+    text: string;
+    hidden?: boolean;
+    userName?: string;
+    assistantName?: string;
+    assistantAvatar?: string;
+}
+export interface ChatStreamReducer {
+    /** Apply one normalized stream event. */
+    apply(event: ChatStreamEvent): void;
+    /** Current immutable state snapshot (stable identity between mutations). */
+    readonly state: ChatReducerState;
+    /** Full reset — thread, per-turn kernel, dedup sets, seq gate, maps. */
+    reset(): void;
+    /**
+     * Seed the thread (history hydration / persisted-state rehydration) and
+     * optionally the per-turn kernel + escalated approvals (resume of an
+     * incomplete turn). `messages: null` keeps the current thread. Escalated
+     * entries are re-surfaced via `onEscalatedApproval` effects. Marks the
+     * instance as having streamed so continuation chunks append.
+     */
+    initializeWithState(messages: UnifiedChatMessage[] | null, extras?: InitializeExtras): void;
+    setMessages(messages: UnifiedChatMessage[]): void;
+    prependMessages(messages: UnifiedChatMessage[]): void;
+    /** Optimistic local send: user bubble (+ echo record) + assistant placeholder. */
+    pushOptimisticSend(text: string, hidden?: boolean): void;
+    /** Wipe thread + per-turn kernel, keep approval statuses (legacy clear). */
+    clearThread(): void;
+    /** Per-dialog reset (keeps approval statuses — request-ids are global). */
+    resetForDialogSwitch(): void;
+    beginSseSend(options: BeginSseSendOptions): void;
+    endSseTurn(): void;
+    failSseTurn(errorMessage: string): void;
+    seedSseMaps(seed: {
+        sources?: Array<[number, unknown[]]>;
+        refs?: Array<[number, Record<string, ChatRef>]>;
+        sendCount?: number;
+    }): void;
+    setPhase(phase: StreamingPhase): void;
+    setApprovalStatus(requestId: string, status: ChatApprovalStatus | null): void;
+    /**
+     * CANONICAL merge of a PERSISTED status map (host-side store, history
+     * hydration, dialog-switch top-up) into this reducer's map.
+     *
+     * Precedence is STATE-MONOTONIC, not source-based, because either side can
+     * be the stale one:
+     *  - persisted lags (a snapshot taken before the stream resolved the
+     *    request) → the stream's resolved status must win, or a just-approved
+     *    card would be downgraded back to `pending` and re-arm its buttons;
+     *  - the STREAM lags (this tab saw the request, the operator resolved it in
+     *    a SECOND TAB, and the persisted map is the one carrying the truth) →
+     *    the persisted resolution must win, or the card stays actionable and
+     *    invites a second approve on an already-resolved request.
+     *
+     * With statuses being exactly `pending | approved | rejected | cancelled`,
+     * "resolved beats pending" is a total order that gets both directions
+     * right: take the persisted value when ours is `pending` and theirs isn't;
+     * keep ours otherwise. Persisted entries still fill in every request-id the
+     * stream hasn't seen (other dialogs, pre-session history).
+     */
+    mergeApprovalStatuses(persisted: Record<string, ChatApprovalStatus>): void;
+    setDirectMode(isDirectMode: boolean): void;
+    setDialogTokenUsage(usage: DialogTokenUsage | null): void;
+    /** +1/-1 windows during catchup replay (suppresses agent-busy locks). */
+    adjustAgentBusySuppression(delta: number): void;
+    armAdoptTrailingAssistant(value: boolean): void;
+    projectApprovalResolution(requestId: string, status: ChatApprovalStatus, resolvedByName?: string | null): void;
+    projectToolExecution(segment: ToolExecutionSegment): void;
+    /**
+     * The seq gate's current value (`-Infinity` before anything seq-carrying was
+     * applied). Not part of `state` — it is bookkeeping, not render input — but
+     * a host that PARKS a reducer (LRU eviction, dialog swap) needs it to
+     * restore idempotency on the recreated instance via
+     * `initializeWithState(messages, { lastAppliedSeq })`.
+     */
+    getLastAppliedSeq(): number;
+    /**
+     * Currently-armed optimistic-echo entries. Same rationale as
+     * `getLastAppliedSeq`: not render input, but a host that PARKS a reducer
+     * needs them to restore echo dedup on the recreated instance via
+     * `initializeWithState(messages, { pendingEchoes })` — otherwise an echo
+     * in flight across the eviction renders a duplicate user bubble.
+     */
+    getPendingEchoes(): readonly PendingEcho[];
+    getSegments(): MessageSegment[];
+    updateApprovalStatus(requestId: string, status: ChatApprovalStatus, resolvedByName?: string | null): MessageSegment[];
+    getPendingEscalated(): Map<string, EscalatedApprovalData>;
+}
+export declare function createChatStreamReducer(options?: ChatStreamReducerOptions): ChatStreamReducer;
+//# sourceMappingURL=chat-stream-reducer.d.ts.map

package/dist/components/chat/stream/chat-stream-reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-stream-reducer.d.ts","sourceRoot":"","sources":["../../../../src/components/chat/stream/chat-stream-reducer.ts"],"names":[],"mappings":"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"}

package/dist/components/chat/stream/delta-batcher.d.ts

@@ -0,0 +1,51 @@
+/**
+ * createDeltaBatcher — framework-free, append-only batching of the
+ * `text-delta` / `thinking-delta` / `guide-delta` events.
+ *
+ * WHY THIS IS SHARED (and not a hook-private detail): every host that drives a
+ * `ChatStreamReducer` from a raw transport needs the SAME batching, and a
+ * copy-paste of it drifts. The React wrapper (`useChatStreamReducer`) and any
+ * non-React mirror in a product app both consume this one implementation.
+ *
+ * Behaviour:
+ *   - `push(event, key)` queues delta events and returns true; anything else
+ *     returns false so the caller can flush + apply it synchronously (ordering:
+ *     completion state must always land on fully-applied deltas).
+ *   - CONSECUTIVE same-type deltas are COALESCED into one event (the reducer's
+ *     append semantics distribute over concatenation), so a 60-delta/sec turn
+ *     costs ONE `applyOne` per frame instead of 60. `text-delta` additionally
+ *     requires a matching `leading` flag before coalescing.
+ *   - A flush is scheduled on `requestAnimationFrame` when available, with a
+ *     timer fallback that is ALWAYS armed (rAF pauses in background tabs, and a
+ *     hidden chat panel must still keep its thread current).
+ *   - `key` is an opaque routing token handed back to `applyOne`. When it
+ *     changes, the pending batch is flushed against the PREVIOUS key first, so
+ *     deltas never land on the wrong dialog/side.
+ */
+import type { ChatStreamEvent, GuideDeltaEvent, TextDeltaEvent, ThinkingDeltaEvent } from '../../../chat-protocol/events';
+export declare const DELTA_FLUSH_FALLBACK_MS = 50;
+export type DeltaEvent = TextDeltaEvent | ThinkingDeltaEvent | GuideDeltaEvent;
+export declare function isDeltaEvent(event: ChatStreamEvent): event is DeltaEvent;
+export interface CreateDeltaBatcherOptions<K> {
+    /** Apply one (possibly coalesced) delta against `key`'s reducer. */
+    applyOne: (event: DeltaEvent, key: K | undefined) => void;
+    /** Called after a flush that applied at least one delta. */
+    onFlushed?: (appliedCount: number) => void;
+    /** Timer fallback in ms (default `DELTA_FLUSH_FALLBACK_MS`). */
+    fallbackMs?: number;
+}
+export interface DeltaBatcher<K = unknown> {
+    /**
+     * Queue `event` when it is a delta (returns true). Non-delta events are NOT
+     * queued and return false — the caller flushes and applies them itself.
+     */
+    push(event: ChatStreamEvent, key?: K): boolean;
+    /** Synchronously apply the pending batch and cancel any scheduled flush. */
+    flush(): void;
+    /** Flush and release timers — call on teardown so tail deltas aren't lost. */
+    dispose(): void;
+    /** Queued (post-coalescing) delta count. Test/diagnostic surface. */
+    readonly pendingCount: number;
+}
+export declare function createDeltaBatcher<K = unknown>({ applyOne, onFlushed, fallbackMs, }: CreateDeltaBatcherOptions<K>): DeltaBatcher<K>;
+//# sourceMappingURL=delta-batcher.d.ts.map

package/dist/components/chat/stream/delta-batcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delta-batcher.d.ts","sourceRoot":"","sources":["../../../../src/components/chat/stream/delta-batcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,cAAc,EACd,kBAAkB,EACnB,MAAM,+BAA+B,CAAA;AAEtC,eAAO,MAAM,uBAAuB,KAAK,CAAA;AAEzC,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG,kBAAkB,GAAG,eAAe,CAAA;AAE9E,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,GAAG,KAAK,IAAI,UAAU,CAMxE;AAED,MAAM,WAAW,yBAAyB,CAAC,CAAC;IAC1C,oEAAoE;IACpE,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,CAAA;IACzD,4DAA4D;IAC5D,SAAS,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1C,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO;IACvC;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAA;IAC9C,4EAA4E;IAC5E,KAAK,IAAI,IAAI,CAAA;IACb,8EAA8E;IAC9E,OAAO,IAAI,IAAI,CAAA;IACf,qEAAqE;IACrE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAC9B;AAED,wBAAgB,kBAAkB,CAAC,CAAC,GAAG,OAAO,EAAE,EAC9C,QAAQ,EACR,SAAS,EACT,UAAoC,GACrC,EAAE,yBAAyB,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAgGhD"}

package/dist/components/chat/stream/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Chat stream module — ONE master reader for every chat event source
+ * (SSE decoder, NATS chunk decoder, historical replay). See
+ * `chat-stream-reducer.ts` for the architecture note.
+ *
+ * NOTE: the pure message-mutation helpers (`appendToTrailingAssistant`,
+ * `applyToolExecutionToMessages`, …) are intentionally NOT star-exported
+ * here — their legacy public home is `use-nats-chat-adapter`, which
+ * re-exports them from `./message-mutations`; exporting the same bindings
+ * from two star-exported barrels would make them ambiguous and drop them
+ * from the chat barrel entirely.
+ */
+export { createChatStreamReducer, createEmptyTurnMeta, type BeginSseSendOptions, type ChatReducerEffect, type ChatReducerState, type ChatStreamReducer, type ChatStreamReducerOptions, type ChatTurnMetaState, type EscalatedApprovalData, type InitializeExtras, type PendingEcho, } from './chat-stream-reducer';
+export { createChatDialogStore, DEFAULT_DIALOG_SIDE, DEFAULT_MAX_REDUCERS, MAX_PENDING_RETAIN_KEYS, type ChatDialogSide, type ChatDialogStore, type CreateChatDialogStoreOptions, type EvictedReducerState, } from './chat-dialog-store';
+export { createDeltaBatcher, type CreateDeltaBatcherOptions, type DeltaBatcher, type DeltaEvent, } from './delta-batcher';
+export { useChatStreamReducer, type UseChatStreamReducerOptions, type UseChatStreamReducerReturn, } from './use-chat-stream-reducer';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/chat/stream/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/chat/stream/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,WAAW,GACjB,MAAM,uBAAuB,CAAA;AAE9B,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACpB,uBAAuB,EACvB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,4BAA4B,EACjC,KAAK,mBAAmB,GACzB,MAAM,qBAAqB,CAAA;AAO5B,OAAO,EACL,kBAAkB,EAClB,KAAK,yBAAyB,EAC9B,KAAK,YAAY,EACjB,KAAK,UAAU,GAChB,MAAM,iBAAiB,CAAA;AAExB,OAAO,EACL,oBAAoB,EACpB,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,GAChC,MAAM,2BAA2B,CAAA"}

package/dist/components/chat/stream/message-mutations.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Pure message-mutation kernel for the master chat-stream reducer.
+ *
+ * These helpers were absorbed from `use-nats-chat-adapter.ts` in Phase 3 of
+ * the chat unification — they are the ONE implementation of "apply a stream
+ * fragment to a message thread". The reducer (`chat-stream-reducer.ts`) and
+ * the cross-side projections (`chat-dialog-store.ts`) both build on them.
+ *
+ * REFERENTIAL-STABILITY CONTRACT: every helper clones ONLY the touched
+ * message object (and the touched segment slot inside it). A value-level
+ * no-op — e.g. a replayed duplicate EXECUTED_TOOL whose merge would write
+ * identical values — returns the PRIOR references untouched, so React
+ * memoization over untouched messages survives redeliveries.
+ *
+ * Framework-free: no React, no timers.
+ */
+import type { ChatApprovalStatus, MessageSegment, ToolExecutionSegment } from '../types';
+import type { UnifiedChatMessage } from '../types/unified-chat-state.types';
+export declare function nextId(role: 'user' | 'assistant'): string;
+/**
+ * Realtime user/direct/system chunks can be replays of rows already on
+ * screen. Content-window dedup is the LAST layer (seq-less transports only)
+ * — see the layer list in `chat-stream-reducer.ts`.
+ */
+export declare const CONTENT_DEDUP_WINDOW = 4;
+export declare const SYSTEM_DEDUP_WINDOW = 10;
+export declare function hasRecentMessage(prev: UnifiedChatMessage[], predicate: (message: UnifiedChatMessage) => boolean, window: number): boolean;
+/**
+ * Replace (or append) the trailing assistant message with the latest
+ * accumulated segments.
+ */
+export declare function updateTrailingAssistant(prev: UnifiedChatMessage[], segments: MessageSegment[]): UnifiedChatMessage[];
+/**
+ * Append-mode counterpart of `updateTrailingAssistant` for post-MESSAGE_END
+ * continuation fragments (`SegmentsUpdateMetadata.append`). Coalesces
+ * trailing fragments of the same type, mirroring the accumulator; approval
+ * deltas upsert by request id so a replayed emit stays idempotent.
+ */
+export declare function appendToTrailingAssistant(prev: UnifiedChatMessage[], segments: MessageSegment[]): UnifiedChatMessage[];
+/**
+ * Upsert a standalone context-compaction segment into the trailing assistant
+ * bubble. Compaction emissions arrive as the accumulator's CUMULATIVE array —
+ * only the compaction segment itself may be applied, or interleaved
+ * continuation text would duplicate. A `completed` segment replaces the last
+ * `started` one in place.
+ */
+export declare function upsertTrailingCompaction(prev: UnifiedChatMessage[], segments: MessageSegment[]): UnifiedChatMessage[];
+/**
+ * Cross-message tool-execution updater for post-MESSAGE_END tool chunks
+ * (approved commands executing after the approval bubble, async batch
+ * results). Scans messages from the end:
+ *  1) an `approval_batch` whose `toolCalls` contains the execution id →
+ *     merge into its `executions` map;
+ *  2) a matching `tool_execution` segment (same id, or EXECUTING with the
+ *     same tool for legacy id-less backends) → update in place;
+ *  3) no match → append the segment to the trailing assistant bubble.
+ *
+ * A value-level no-op (replayed duplicate) returns `prev` untouched.
+ */
+export declare function applyToolExecutionToMessages(prev: UnifiedChatMessage[], segment: ToolExecutionSegment): UnifiedChatMessage[];
+/**
+ * Merge-only variant of `applyToolExecutionToMessages` — the pure projection
+ * used for the cross-SIDE fan-out in `chat-dialog-store.ts`. Updates a
+ * matching batch slot / tool segment when present; returns `null` when
+ * nothing matches (the caller decides whether to append — projections never
+ * do, so a tool that belongs to one side only never grows a card on the
+ * other).
+ */
+export declare function mergeToolExecutionIfPresent(prev: UnifiedChatMessage[], segment: ToolExecutionSegment): UnifiedChatMessage[] | null;
+/**
+ * Cross-message approval status flip (absorbed from the NATS adapter's
+ * `onApprovalResolved` handler). Idempotent + reference-preserving: only the
+ * messages/segments whose status (or resolvedByName) actually changes are
+ * cloned; a no-op returns `prev`.
+ */
+export declare function projectApprovalResolutionToMessages(prev: UnifiedChatMessage[], requestId: string, status: ChatApprovalStatus, resolvedByName?: string | null): UnifiedChatMessage[];
+//# sourceMappingURL=message-mutations.d.ts.map

package/dist/components/chat/stream/message-mutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-mutations.d.ts","sourceRoot":"","sources":["../../../../src/components/chat/stream/message-mutations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAEV,kBAAkB,EAClB,cAAc,EACd,oBAAoB,EAErB,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,CAKzD;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,IAAI,CAAA;AACrC,eAAO,MAAM,mBAAmB,KAAK,CAAA;AAErC,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,kBAAkB,EAAE,EAC1B,SAAS,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,OAAO,EACnD,MAAM,EAAE,MAAM,GACb,OAAO,CAMT;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,kBAAkB,EAAE,EAC1B,QAAQ,EAAE,cAAc,EAAE,GACzB,kBAAkB,EAAE,CAetB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,kBAAkB,EAAE,EAC1B,QAAQ,EAAE,cAAc,EAAE,GACzB,kBAAkB,EAAE,CAgDtB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,kBAAkB,EAAE,EAC1B,QAAQ,EAAE,cAAc,EAAE,GACzB,kBAAkB,EAAE,CAsBtB;AA2BD;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,kBAAkB,EAAE,EAC1B,OAAO,EAAE,oBAAoB,GAC5B,kBAAkB,EAAE,CAItB;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,kBAAkB,EAAE,EAC1B,OAAO,EAAE,oBAAoB,GAC5B,kBAAkB,EAAE,GAAG,IAAI,CA4E7B;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,kBAAkB,EAAE,EAC1B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,kBAAkB,EAC1B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,GAC7B,kBAAkB,EAAE,CAuBtB"}

package/dist/components/chat/stream/use-chat-stream-reducer.d.ts

@@ -0,0 +1,22 @@
+import type { ChatStreamEvent } from '../../../chat-protocol/events';
+import { type ChatDialogSide, type ChatDialogStore } from './chat-dialog-store';
+import type { ChatReducerState, ChatStreamReducer, ChatStreamReducerOptions } from './chat-stream-reducer';
+export interface UseChatStreamReducerOptions {
+    store: ChatDialogStore;
+    dialogId: string;
+    side?: ChatDialogSide;
+    /** Consulted once, when this (dialogId, side) reducer is first created. */
+    createReducerOptions?: () => ChatStreamReducerOptions;
+}
+export interface UseChatStreamReducerReturn {
+    state: ChatReducerState;
+    /** Apply a decoded event (deltas are batched; everything else immediate). */
+    applyEvent: (event: ChatStreamEvent) => void;
+    /** Synchronously apply any pending delta batch. */
+    flushDeltas: () => void;
+    /** Run reducer commands (adapter-driven, non-wire mutations). */
+    mutate: <T>(fn: (reducer: ChatStreamReducer) => T) => T;
+    reducer: ChatStreamReducer;
+}
+export declare function useChatStreamReducer({ store, dialogId, side, createReducerOptions, }: UseChatStreamReducerOptions): UseChatStreamReducerReturn;
+//# sourceMappingURL=use-chat-stream-reducer.d.ts.map

package/dist/components/chat/stream/use-chat-stream-reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-chat-stream-reducer.d.ts","sourceRoot":"","sources":["../../../../src/components/chat/stream/use-chat-stream-reducer.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AACpE,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACzB,MAAM,uBAAuB,CAAA;AAO9B,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,eAAe,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,cAAc,CAAA;IACrB,2EAA2E;IAC3E,oBAAoB,CAAC,EAAE,MAAM,wBAAwB,CAAA;CACtD;AAED,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,gBAAgB,CAAA;IACvB,6EAA6E;IAC7E,UAAU,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAA;IAC5C,mDAAmD;IACnD,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB,iEAAiE;IACjE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,CAAC,KAAK,CAAC,CAAA;IACvD,OAAO,EAAE,iBAAiB,CAAA;CAC3B;AAED,wBAAgB,oBAAoB,CAAC,EACnC,KAAK,EACL,QAAQ,EACR,IAA0B,EAC1B,oBAAoB,GACrB,EAAE,2BAA2B,GAAG,0BAA0B,CAiE1D"}