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

package/dist/components/chat/index.js

@@ -88,7 +88,9 @@ import {
   ContextMenuRow,
   CustomerInterviewCard,
   CustomerInterviewCardSkeleton,
+  DEFAULT_DIALOG_SIDE,
   DEFAULT_DOCUMENT_TYPE_TO_TABLE_ID,
+  DEFAULT_MAX_REDUCERS,
   DataRoomDocCard,
   DataRoomDocCardSkeleton,
   DialogListItem,
@@ -114,6 +116,7 @@ import {
   ICON_REGISTRY,
   InvestorUpdateCard,
   InvestorUpdateCardSkeleton,
+  MAX_PENDING_RETAIN_KEYS,
   MESSAGE_ROLE,
   MESSAGE_TYPE,
   MemoizedChatMessageEnhanced,
@@ -180,8 +183,13 @@ import {
   clickupTaskUrl,
   computeHistoryPrepend,
   computeIsNewTab,
+  createChatDialogStore,
+  createChatStreamReducer,
+  createDeltaBatcher,
+  createEmptyTurnMeta,
   createMessageSegmentAccumulator,
   decideNewTab,
+  decodeHistoricalMessageData,
   defaultBuildProductReleaseCardProps,
   defaultTableIdForDocumentType,
   escapeMarkdownInline,
@@ -190,7 +198,7 @@ import {
   extractEntityIdFilter,
   extractErrorMessages,
   extractIncompleteMessageState,
-  extractTextFromChunk,
+  extractIncompleteTailState,
   fetchEmptyStateConfig,
   fetchSlashCommands,
   flattenAssistantContent,
@@ -210,11 +218,8 @@ import {
   hideOnError,
   historicalToUnified,
   interleave,
-  isControlChunk,
   isCrossOriginUrl,
-  isErrorChunk,
   isHistoricalUserTurn,
-  isMetadataChunk,
   isModifierClick,
   isQuickActionIconSpec,
   isStructuredContent,
@@ -225,7 +230,6 @@ import {
   normalizeContent,
   normalizeHistoricalMessageData,
   normalizeIconKey,
-  parseChunkToAction,
   parseScrollAnchor,
   parseWireCommandOverride,
   processHistoricalMessages,
@@ -252,6 +256,7 @@ import {
   useChatAttachments,
   useChatCardItem,
   useChatIdentity,
+  useChatStreamReducer,
   useChunkCatchup,
   useCloseOnNavigation,
   useCollapsible,
@@ -261,14 +266,13 @@ import {
   useNatsChatAdapter,
   useNatsDialogSubscription,
   useProxiedImageUrl,
-  useRealtimeChunkProcessor,
   useSSE,
   useScriptedStream,
   useSlashCommandRegistry,
   useSlashCommands,
   useSseChatAdapter,
   useUnifiedChat
-} from "../../chunk-OQIMH2WQ.js";
+} from "../../chunk-MEMRQTOI.js";
 import {
   applyProxyAuth,
   clearEmbedProxyAuth,
@@ -276,14 +280,14 @@ import {
   getEmbedProxyAuth,
   getPersistedProxyEmail,
   setEmbedProxyAuth
-} from "../../chunk-PB3BTZDU.js";
+} from "../../chunk-WEUNPE3S.js";
 import "../../chunk-OYGFWWLQ.js";
 import "../../chunk-6GT557KN.js";
 import "../../chunk-7EUIW46X.js";
 import "../../chunk-EL5YVPD5.js";
 import "../../chunk-ZJJERZUA.js";
 import "../../chunk-LXC6P2EO.js";
-import "../../chunk-GZK7FWJJ.js";
+import "../../chunk-QKWOBV55.js";
 import "../../chunk-6U3IUD57.js";
 import "../../chunk-OHPI2HRK.js";
 import "../../chunk-SZMA65OW.js";
@@ -380,7 +384,9 @@ export {
   ContextMenuRow,
   CustomerInterviewCard,
   CustomerInterviewCardSkeleton,
+  DEFAULT_DIALOG_SIDE,
   DEFAULT_DOCUMENT_TYPE_TO_TABLE_ID,
+  DEFAULT_MAX_REDUCERS,
   DataRoomDocCard,
   DataRoomDocCardSkeleton,
   DialogListItem,
@@ -406,6 +412,7 @@ export {
   ICON_REGISTRY,
   InvestorUpdateCard,
   InvestorUpdateCardSkeleton,
+  MAX_PENDING_RETAIN_KEYS,
   MESSAGE_ROLE,
   MESSAGE_TYPE,
   MessageSegmentAccumulator,
@@ -474,8 +481,13 @@ export {
   clickupTaskUrl,
   computeHistoryPrepend,
   computeIsNewTab,
+  createChatDialogStore,
+  createChatStreamReducer,
+  createDeltaBatcher,
+  createEmptyTurnMeta,
   createMessageSegmentAccumulator,
   decideNewTab,
+  decodeHistoricalMessageData,
   defaultBuildProductReleaseCardProps,
   defaultTableIdForDocumentType,
   escapeMarkdownInline,
@@ -484,7 +496,7 @@ export {
   extractEntityIdFilter,
   extractErrorMessages,
   extractIncompleteMessageState,
-  extractTextFromChunk,
+  extractIncompleteTailState,
   fetchEmptyStateConfig,
   fetchSlashCommands,
   flattenAssistantContent,
@@ -506,11 +518,8 @@ export {
   hideOnError,
   historicalToUnified,
   interleave,
-  isControlChunk,
   isCrossOriginUrl,
-  isErrorChunk,
   isHistoricalUserTurn,
-  isMetadataChunk,
   isModifierClick,
   isQuickActionIconSpec,
   isStructuredContent,
@@ -521,7 +530,6 @@ export {
   normalizeContent,
   normalizeHistoricalMessageData,
   normalizeIconKey,
-  parseChunkToAction,
   parseScrollAnchor,
   parseWireCommandOverride,
   processHistoricalMessages,
@@ -549,6 +557,7 @@ export {
   useChatAttachments,
   useChatCardItem,
   useChatIdentity,
+  useChatStreamReducer,
   useChunkCatchup,
   useCloseOnNavigation,
   useCollapsible,
@@ -559,7 +568,6 @@ export {
   useNatsChatAdapter,
   useNatsDialogSubscription,
   useProxiedImageUrl,
-  useRealtimeChunkProcessor,
   useSSE,
   useScriptedStream,
   useSlashCommandRegistry,

package/dist/components/chat/stream/chat-dialog-store.d.ts

@@ -0,0 +1,184 @@
+/**
+ * createChatDialogStore — framework-free registry of `ChatStreamReducer`
+ * instances keyed by `(dialogId, side)`. Reducer state PERSISTS across
+ * component unmounts (the store outlives React), and the store is the
+ * `useSyncExternalStore` source for the `useChatStreamReducer` wrapper.
+ *
+ * CROSS-SIDE PROJECTION: exactly two operations fan out across sides of the
+ * same dialogId —
+ *   1. approval RESOLUTION by requestId (`approval-resolved` events), and
+ *   2. tool-execution MERGE by execId (`tool-execution` events)
+ * — implemented as idempotent pure projections over the other side's state
+ * (recomputed from state, never re-injected into the other side's seq
+ * stream; per-side seq gates stay untouched). Everything else — text,
+ * thinking, participant rows — is strictly per-side.
+ *
+ * LIFECYCLE / MEMORY: the reducer map is LRU-capped (`maxReducers`, default
+ * `DEFAULT_MAX_REDUCERS`) and evicted through the same path as `remove()`.
+ * Without a cap an agent cycling hundreds of dialogs would retain a reducer
+ * (thread + accumulator) per dialog for the process's lifetime; under SSR,
+ * where the store is module-scoped, that growth is shared across every
+ * request. `getSnapshot` is PURE — it never creates an entry — and
+ * `getServerSnapshot` always returns the shared frozen `EMPTY_STATE`.
+ *
+ * EVICTION SAFETY (LRU recency alone is NOT liveness):
+ *   1. RETAINED keys are never evicted. `retain(dialogId, side)` returns a
+ *      release fn; the `useChatStreamReducer` hook calls it for as long as it
+ *      is mounted, so a quiet-but-visible panel can't be dropped just because
+ *      ten other keys were touched. NON-React hosts must call it too.
+ *      Because the hook retains in an EFFECT but takes its reducer during
+ *      RENDER, a key created by a public `getReducer` is protected from
+ *      creation until its FIRST `retain()` (bounded by
+ *      `MAX_PENDING_RETAIN_KEYS`) — see `pendingRetain`.
+ *   2. A reducer whose `streamingPhase !== 'idle'` is never evicted — dropping
+ *      mid-turn would recreate an EMPTY reducer on the next `getReducer`
+ *      while the host's seq cursor still says "caught up", i.e. the thread
+ *      visually vanishes with no path back.
+ *   3. Eviction hands the host the dropped instance's PARKED state
+ *      (`onEvict(..., { messages, approvalStatuses, lastAppliedSeq,
+ *      pendingEchoes })`). A recreated reducer is pristine, so re-seeding
+ *      messages alone would
+ *      resurrect resolved approvals as actionable and reset the seq gate to
+ *      `-Infinity`; the parked payload is what makes the round-trip lossless.
+ *   4. Eviction NEVER notifies synchronously. `getReducer` is called during
+ *      render (by the hook), and notifying there means updating other
+ *      components mid-render. The notify is deferred to a microtask.
+ */
+import { type ChatReducerState, type ChatStreamReducer, type ChatStreamReducerOptions, type PendingEcho } from './chat-stream-reducer';
+import type { ChatStreamEvent } from '../../../chat-protocol/events';
+export type ChatDialogSide = string;
+/** Factory for a key's reducer options, consulted ONCE at creation. A plain
+ *  `() => options` thunk remains assignable. */
+export type CreateReducerOptionsFn = (dialogId: string, side: ChatDialogSide) => ChatStreamReducerOptions;
+export interface ChatDialogStore {
+    /** Create-or-get the reducer for `(dialogId, side)`. `createOptions` is
+     *  consulted ONLY when the instance is first created. */
+    getReducer(dialogId: string, side?: ChatDialogSide, createOptions?: CreateReducerOptionsFn): ChatStreamReducer;
+    /** Apply one event to a side, then fan out the cross-side projections to
+     *  the other sides of the same dialog. */
+    apply(dialogId: string, side: ChatDialogSide, event: ChatStreamEvent): void;
+    /** Run adapter commands against a reducer; subscribers are notified. */
+    mutate<T>(dialogId: string, side: ChatDialogSide, fn: (reducer: ChatStreamReducer) => T): T;
+    subscribe(listener: () => void): () => void;
+    /**
+     * Referentially-stable snapshot for `useSyncExternalStore`. PURE — an
+     * unknown key returns the shared frozen `EMPTY_STATE` rather than
+     * creating a reducer (a create-on-read would let SSR renders accumulate
+     * reducers in a process-global map, and would make React's snapshot read
+     * a mutation).
+     */
+    getSnapshot(dialogId: string, side?: ChatDialogSide): ChatReducerState;
+    /** `useSyncExternalStore`'s server getter — always `EMPTY_STATE`. There is
+     *  no per-request store on the server, so a live thread cannot be rendered
+     *  server-side; the client hydrates from the real reducer. */
+    getServerSnapshot(): ChatReducerState;
+    /** Drop a side's reducer (or every side of the dialog when omitted). */
+    remove(dialogId: string, side?: ChatDialogSide): void;
+    /**
+     * PIN `(dialogId, side)` against LRU eviction while a consumer is live.
+     * Returns the release fn (idempotent; refcounted, so nested retains are
+     * safe). Creation is NOT implied — retaining an absent key simply means the
+     * key is protected once it exists.
+     */
+    retain(dialogId: string, side?: ChatDialogSide): () => void;
+    /**
+     * POLICY retain: keep exactly `keys` pinned by this store-level set and
+     * release every key the set previously pinned. Independent of the refcounted
+     * `retain()` handles a host's components hold — the two compose.
+     *
+     * Exists because "retain this set, release the rest" is generic store
+     * policy that every multi-panel host otherwise re-derives (diffing its own
+     * key list against a map of release fns). Retains BEFORE releasing, so a key
+     * present in both the old and the new set never momentarily drops to zero
+     * retains and becomes evictable mid-swap.
+     */
+    setRetained(keys: Array<{
+        dialogId: string;
+        side?: ChatDialogSide;
+    }>): void;
+}
+export declare const DEFAULT_DIALOG_SIDE: ChatDialogSide;
+/** Most-recently-used reducer keys retained before eviction. Ten covers
+ *  every realistic multi-panel / dialog-switching session while bounding an
+ *  agent that cycles hundreds of dialogs. */
+export declare const DEFAULT_MAX_REDUCERS = 10;
+/**
+ * Hard cap on keys held in the "created by `getReducer`, `retain()` still
+ * pending" protection set — the ONLY thing bounding the map while retains are
+ * outstanding, since that protection ends at the retain rather than on a timer.
+ *
+ * Deliberately far above `maxReducers`: a host may legitimately mount MORE
+ * panels than the LRU cap (once their effects run, retained keys already let
+ * the map exceed it), so capping the pending set at `maxReducers` would blank
+ * exactly the panels round 10 fixed. It is a backstop against a caller that
+ * reads a reducer once and drops it — or a concurrent render React discards
+ * before any effect runs — not a per-commit budget. Past it, the oldest pending
+ * key falls through to ordinary LRU.
+ */
+export declare const MAX_PENDING_RETAIN_KEYS = 256;
+export interface CreateChatDialogStoreOptions {
+    /** LRU cap on retained reducers (keys are `(dialogId, side)` pairs).
+     *  Values < 1 are clamped to 1. Default `DEFAULT_MAX_REDUCERS`. */
+    maxReducers?: number;
+    /**
+     * Options applied to any reducer this store creates WITHOUT an explicit
+     * per-call `createOptions` — i.e. every reducer first materialized by
+     * `apply()` or `mutate()`. Hosts with non-default reducer semantics
+     * (`ownEchoIncludesAdmin`, `selfUserId`, approve/reject `callbacks`, …)
+     * MUST set this: creation options are consulted once, so a bare
+     * apply-created instance would keep those semantics missing for its whole
+     * lifetime, including for a later `getReducer(..., options)` caller.
+     */
+    defaultCreateOptions?: CreateReducerOptionsFn;
+    /**
+     * Called when LRU eviction actually DROPS a key. The store knows this
+     * exactly; without publishing it, hosts are left inferring eviction by
+     * comparing reducer OBJECT IDENTITY across `getReducer` calls and then
+     * suppressing the "pristine empty" snapshot that a silently-recreated
+     * reducer returns — archaeology about a fact this callback states outright.
+     *
+     * Fires only for LRU eviction. Host-initiated `remove()` needs no
+     * notification: the caller already knows which key it dropped.
+     *
+     * Called AFTER the key is gone, from `getReducer` (i.e. potentially during a
+     * React render) — treat it as a "schedule a refetch/rehydrate" signal, not a
+     * place to set state synchronously.
+     *
+     * `parked` carries the dropped reducer's non-refetchable state so the host
+     * can restore it on the recreated instance (`initializeWithState(messages,
+     * { approvalStatuses, lastAppliedSeq, pendingEchoes })`). Refetching
+     * messages alone is NOT
+     * equivalent: a recreated reducer starts with `approvalStatuses = {}` and
+     * `lastAppliedSeq = -Infinity`, so a resolved approval whose APPROVAL_RESULT
+     * row is not in the refetched history page re-renders as ACTIONABLE (the
+     * exact hazard `resetForDialogSwitch` preserves that map to avoid), and a
+     * replay from the host's own cursor re-applies events the dropped instance
+     * had already consumed.
+     */
+    onEvict?: (dialogId: string, side: ChatDialogSide, parked: EvictedReducerState) => void;
+}
+/**
+ * Snapshot of an LRU-evicted reducer's state, captured just before the
+ * instance is dropped. Everything here either cannot be refetched
+ * (`lastAppliedSeq`) or is not reliably present in a refetched history page
+ * (`approvalStatuses`); `messages` rides along so a host that keeps its own
+ * copy does not have to.
+ */
+export interface EvictedReducerState {
+    messages: ChatReducerState['messages'];
+    approvalStatuses: ChatReducerState['approvalStatuses'];
+    /** `-Infinity` when the instance never applied a seq-carrying event. */
+    lastAppliedSeq: number;
+    /**
+     * Optimistic-echo entries still armed at eviction time. A key dropped
+     * between `pushOptimisticSend` and its `MESSAGE_REQUEST` echo would
+     * otherwise leave the recreated reducer with nothing armed, and the echo
+     * renders a DUPLICATE user bubble. Replay via
+     * `initializeWithState(messages, { pendingEchoes })`; the reducer drops
+     * entries already past `OWN_ECHO_AUTHOR_TTL_MS`. Empty for a key with no
+     * send in flight (the common case).
+     */
+    pendingEchoes: readonly PendingEcho[];
+}
+export declare function createChatDialogStore(options?: CreateChatDialogStoreOptions): ChatDialogStore;
+//# sourceMappingURL=chat-dialog-store.d.ts.map

package/dist/components/chat/stream/chat-dialog-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-dialog-store.d.ts","sourceRoot":"","sources":["../../../../src/components/chat/stream/chat-dialog-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,WAAW,EACjB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAEpE,MAAM,MAAM,cAAc,GAAG,MAAM,CAAA;AAEnC;gDACgD;AAChD,MAAM,MAAM,sBAAsB,GAAG,CACnC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,cAAc,KACjB,wBAAwB,CAAA;AAE7B,MAAM,WAAW,eAAe;IAC9B;6DACyD;IACzD,UAAU,CACR,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,cAAc,EACrB,aAAa,CAAC,EAAE,sBAAsB,GACrC,iBAAiB,CAAA;IACpB;8CAC0C;IAC1C,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,GAAG,IAAI,CAAA;IAC3E,wEAAwE;IACxE,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,CAAC,GAAG,CAAC,CAAA;IAC3F,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAA;IAC3C;;;;;;OAMG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,gBAAgB,CAAA;IACtE;;kEAE8D;IAC9D,iBAAiB,IAAI,gBAAgB,CAAA;IACrC,wEAAwE;IACxE,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,IAAI,CAAA;IACrD;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,MAAM,IAAI,CAAA;IAC3D;;;;;;;;;;OAUG;IACH,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,cAAc,CAAA;KAAE,CAAC,GAAG,IAAI,CAAA;CAC5E;AAED,eAAO,MAAM,mBAAmB,EAAE,cAAuB,CAAA;AAEzD;;6CAE6C;AAC7C,eAAO,MAAM,oBAAoB,KAAK,CAAA;AAEtC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAE1C,MAAM,WAAW,4BAA4B;IAC3C;uEACmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;;;;OAQG;IACH,oBAAoB,CAAC,EAAE,sBAAsB,CAAA;IAC7C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,OAAO,CAAC,EAAE,CACR,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,mBAAmB,KACxB,IAAI,CAAA;CACV;AAED;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAA;IACtC,gBAAgB,EAAE,gBAAgB,CAAC,kBAAkB,CAAC,CAAA;IACtD,wEAAwE;IACxE,cAAc,EAAE,MAAM,CAAA;IACtB;;;;;;;;OAQG;IACH,aAAa,EAAE,SAAS,WAAW,EAAE,CAAA;CACtC;AAyBD,wBAAgB,qBAAqB,CACnC,OAAO,GAAE,4BAAiC,GACzC,eAAe,CAgTjB"}