@djangocfg/ui-tools 2.1.449 → 2.1.452

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@djangocfg/ui-tools",
-  "version": "2.1.449",
+  "version": "2.1.452",
   "description": "Heavy React tools with lazy loading - for Electron, Vite, CRA, Next.js apps",
   "keywords": [
     "ui-tools",
@@ -334,8 +334,8 @@
     "test:watch": "vitest"
   },
   "peerDependencies": {
-    "@djangocfg/i18n": "^2.1.449",
-    "@djangocfg/ui-core": "^2.1.449",
+    "@djangocfg/i18n": "^2.1.452",
+    "@djangocfg/ui-core": "^2.1.452",
     "consola": "^3.4.2",
     "lodash-es": "^4.18.1",
     "lucide-react": "^0.545.0",
@@ -418,9 +418,9 @@
     "@maplibre/maplibre-gl-geocoder": "^1.7.0"
   },
   "devDependencies": {
-    "@djangocfg/i18n": "^2.1.449",
-    "@djangocfg/typescript-config": "^2.1.449",
-    "@djangocfg/ui-core": "^2.1.449",
+    "@djangocfg/i18n": "^2.1.452",
+    "@djangocfg/typescript-config": "^2.1.452",
+    "@djangocfg/ui-core": "^2.1.452",
     "@types/lodash-es": "^4.17.12",
     "@types/mapbox__mapbox-gl-draw": "^1.4.8",
     "@types/node": "^25.2.3",

package/src/tools/chat/core/__tests__/reducer.error-persist.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from 'vitest';
+
+import type { ChatMessage } from '../../types';
+import { initialState, reducer, type ChatAction, type ChatState } from '../reducer';
+
+/**
+ * Regression: an errored turn's banner must PERSIST until a genuinely new
+ * answer turn begins. A prior "anti-jitter" fix (clear `error` on
+ * STREAM_CHUNK / STREAM_DONE / MESSAGE_USER_ADD) over-reached and wiped the
+ * CURRENT turn's error before the user could read it — most visibly the
+ * router-404 case, where STREAM_ERROR + a terminal message_end land on the
+ * SAME turn so the terminal erased its own banner.
+ */
+
+const user = (id: string, content = 'hi'): ChatMessage => ({
+  id,
+  role: 'user',
+  content,
+  createdAt: 1,
+});
+
+/** Replay a sequence of actions from `initialState`. */
+function run(actions: ChatAction[]): ChatState {
+  return actions.reduce(reducer, initialState);
+}
+
+describe('reducer — errored turn banner persistence', () => {
+  it('(a) STREAM_ERROR then STREAM_DONE for the SAME turn keeps the error (router-404)', () => {
+    const state = run([
+      { type: 'MESSAGE_USER_ADD', message: user('u1') },
+      { type: 'STREAM_START', id: 'a1' },
+      { type: 'STREAM_ERROR', id: 'a1', message: 'llm: router 404: 404 page not found' },
+      // The terminal message_end arrives for the very same turn.
+      { type: 'STREAM_DONE', id: 'a1' },
+    ]);
+
+    // The banner survives the turn's own terminal — this is the load-bearing
+    // assertion (what the user reads). The empty errored placeholder itself is
+    // dropped by the HITL empty-bubble logic, which is fine.
+    expect(state.error).toBe('llm: router 404: 404 page not found');
+    expect(state.errorTurnId).toBe('a1');
+    expect(state.isStreaming).toBe(false);
+  });
+
+  it('the errored turn keeps its error message when it produced content', () => {
+    // Same-turn STREAM_DONE must not wipe the banner even when the errored
+    // message survives the empty-bubble drop (it has content).
+    const state = run([
+      { type: 'STREAM_START', id: 'a1' },
+      { type: 'STREAM_CHUNK', delta: 'partial ' },
+      { type: 'STREAM_ERROR', id: 'a1', message: 'boom' },
+      { type: 'STREAM_DONE', id: 'a1' },
+    ]);
+    expect(state.error).toBe('boom');
+    expect(state.errorTurnId).toBe('a1');
+    const msg = state.messages.find((m) => m.id === 'a1');
+    expect(msg?.isError).toBe(true);
+    expect(msg?.content).toBe('partial ');
+  });
+
+  it('a trailing STREAM_CHUNK landing on nothing does not wipe the banner', () => {
+    const state = run([
+      { type: 'STREAM_START', id: 'a1' },
+      { type: 'STREAM_ERROR', id: 'a1', message: 'boom' },
+      // STREAM_ERROR cleared isStreaming, so this chunk finds no streaming
+      // message (idx === -1) and must not clear the error.
+      { type: 'STREAM_CHUNK', delta: 'x' },
+    ]);
+    expect(state.error).toBe('boom');
+    expect(state.errorTurnId).toBe('a1');
+  });
+
+  it('(b) STREAM_ERROR then MESSAGE_USER_ADD keeps the error while the user types the next message', () => {
+    const state = run([
+      { type: 'STREAM_START', id: 'a1' },
+      { type: 'STREAM_ERROR', id: 'a1', message: 'boom' },
+      { type: 'MESSAGE_USER_ADD', message: user('u2', 'try again') },
+    ]);
+
+    expect(state.error).toBe('boom');
+    expect(state.errorTurnId).toBe('a1');
+    // The new user message is appended.
+    expect(state.messages.some((m) => m.id === 'u2')).toBe(true);
+  });
+
+  it('(c) a genuinely NEW turn (STREAM_START + STREAM_CHUNK) clears the stale error', () => {
+    const errored = run([
+      { type: 'STREAM_START', id: 'a1' },
+      { type: 'STREAM_ERROR', id: 'a1', message: 'boom' },
+      { type: 'MESSAGE_USER_ADD', message: user('u2') },
+    ]);
+    expect(errored.error).toBe('boom');
+
+    // New turn opens with a fresh placeholder id.
+    const afterStart = reducer(errored, { type: 'STREAM_START', id: 'a2' });
+    expect(afterStart.error).toBeNull();
+    expect(afterStart.errorTurnId).toBeNull();
+
+    // And, independently, the first chunk of a new turn also clears it.
+    const viaChunk = reducer(
+      reducer(errored, { type: 'STREAM_START', id: 'a2' } as ChatAction),
+      { type: 'STREAM_CHUNK', delta: 'Hello' },
+    );
+    expect(viaChunk.error).toBeNull();
+    expect(viaChunk.errorTurnId).toBeNull();
+    expect(viaChunk.messages.find((m) => m.id === 'a2')?.content).toBe('Hello');
+  });
+
+  it('re-emitted STREAM_START for the errored turn itself does NOT clear its banner', () => {
+    // Not a strictly newer turn — same id.
+    const state = run([
+      { type: 'STREAM_START', id: 'a1' },
+      { type: 'STREAM_ERROR', id: 'a1', message: 'boom' },
+    ]);
+    const again = reducer(state, { type: 'STREAM_START', id: 'a1' });
+    // STREAM_START while not streaming re-adds a placeholder, but since the id
+    // matches errorTurnId the banner survives.
+    expect(again.error).toBe('boom');
+    expect(again.errorTurnId).toBe('a1');
+  });
+
+  it('(d) HITL empty-placeholder STREAM_DONE still drops the empty bubble', () => {
+    // First stream produced only tool calls + approval_required, no text body.
+    const state = run([
+      { type: 'STREAM_START', id: 'a1' },
+      { type: 'STREAM_DONE', id: 'a1' }, // empty content, no toolCalls
+    ]);
+    expect(state.messages.find((m) => m.id === 'a1')).toBeUndefined();
+    expect(state.isStreaming).toBe(false);
+    // No error was ever set.
+    expect(state.error).toBeNull();
+  });
+
+  it('STREAM_ERROR without an id falls back to the last streaming placeholder id', () => {
+    const state = run([
+      { type: 'STREAM_START', id: 'a1' },
+      { type: 'STREAM_ERROR', message: 'network dropped' },
+    ]);
+    expect(state.error).toBe('network dropped');
+    expect(state.errorTurnId).toBe('a1');
+  });
+});

package/src/tools/chat/core/reducer.ts

@@ -32,6 +32,15 @@ export interface ChatState {
   hasMore: boolean;
   oldestCursor: string | null;
   error: string | null;
+  /**
+   * The message id of the turn the current `error` belongs to (the assistant
+   * placeholder that errored), or null. Lets the reducer keep an errored turn's
+   * banner visible until a *strictly newer* turn begins — the errored turn's own
+   * terminal (STREAM_DONE), its trailing chunks, and the user typing the next
+   * message must NOT clear it; only a new turn's STREAM_START / first STREAM_CHunk
+   * (landing on a different id) does. Cleared alongside `error`.
+   */
+  errorTurnId: string | null;
 }
 
 export const initialState: ChatState = {
@@ -44,6 +53,7 @@ export const initialState: ChatState = {
   hasMore: true,
   oldestCursor: null,
   error: null,
+  errorTurnId: null,
 };
 
 export type ChatAction =
@@ -154,6 +164,7 @@ export function reducer(state: ChatState, action: ChatAction): ChatState {
         // loadHistory → HISTORY_LOAD_DONE) leaves `historyLoaded` untouched.
         historyLoaded: action.messages !== undefined ? true : state.historyLoaded,
         error: null,
+        errorTurnId: null,
       };
 
     case 'HISTORY_LOAD_START':
@@ -183,10 +194,13 @@ export function reducer(state: ChatState, action: ChatAction): ChatState {
       };
 
     case 'MESSAGE_USER_ADD':
+      // Do NOT clear `error` here: the prior turn's banner must stay readable
+      // while the user types + sends the next message. It is retracted only
+      // once the next answer actually begins (STREAM_START / first STREAM_CHUNK
+      // of the new turn), keyed off `errorTurnId`.
       return {
         ...state,
         messages: [...state.messages, action.message],
-        error: null,
       };
 
     case 'STREAM_START': {
@@ -204,23 +218,37 @@ export function reducer(state: ChatState, action: ChatAction): ChatState {
         createdAt: action.createdAt ?? Date.now(),
         isStreaming: true,
       };
+      // A genuinely new answer turn is opening. If a stale error from a prior
+      // turn is still showing, retract it now so the banner can't sit above the
+      // new live answer. Only clear when this is a STRICTLY newer turn (a
+      // different id than the one that errored) — a re-emitted STREAM_START for
+      // the errored turn itself must not wipe its own still-unread banner.
+      const clearStaleError = state.error && state.errorTurnId !== action.id;
       return {
         ...state,
         isStreaming: true,
         messages: [...state.messages, placeholder],
+        ...(clearStaleError ? { error: null, errorTurnId: null } : {}),
       };
     }
 
     case 'STREAM_CHUNK': {
+      const idx = findLastStreamingIndex(state.messages);
       const messages = updateLastStreaming(state.messages, (m) => ({
         ...m,
         content: m.content + action.delta,
       }));
-      // Content is now streaming in for the current turn (STREAM_START opened a
-      // fresh placeholder; chunks only land on it). If an error from a prior
-      // turn is still showing, retract it the moment a good answer begins so
-      // the banner can't sit above live content. Only touch `error` when set.
-      return state.error ? { ...state, error: null, messages } : { ...state, messages };
+      // Content is streaming in. Retract a stale error only when this chunk
+      // lands on a REAL assistant message whose id differs from `errorTurnId`
+      // — i.e. a strictly newer turn. A trailing chunk of the errored turn
+      // itself (same id), or a chunk that lands on nothing (idx === -1), must
+      // NOT wipe the still-unread banner.
+      const landingId = idx === -1 ? null : state.messages[idx].id;
+      const clearStaleError =
+        state.error !== null && landingId !== null && landingId !== state.errorTurnId;
+      return clearStaleError
+        ? { ...state, error: null, errorTurnId: null, messages }
+        : { ...state, messages };
     }
 
     case 'STREAM_TOOL_ACTIVITY': {
@@ -293,11 +321,13 @@ export function reducer(state: ChatState, action: ChatAction): ChatState {
         msg && !msg.content && !(msg.toolCalls?.length)
           ? patched.filter((m) => m.id !== action.id)
           : patched;
-      // A turn that reaches message_end completed successfully (error is the
-      // other terminal event — the two are mutually exclusive per turn). Any
-      // `error` still in state therefore belongs to a prior turn and is now
-      // stale, so clear it: otherwise the banner lingers above a good answer.
-      return { ...state, isStreaming: false, error: null, messages };
+      // Do NOT clear `error` here. STREAM_ERROR + a terminal message_end can
+      // arrive for the SAME turn (e.g. router 404), so wiping `error` on the
+      // terminal would erase the current turn's own banner before the user can
+      // read it. A stale error from a prior turn is instead retracted when the
+      // NEXT turn begins (STREAM_START / first STREAM_CHUNK), keyed off
+      // `errorTurnId`.
+      return { ...state, isStreaming: false, messages };
     }
 
     case 'STREAM_CANCELLED': {
@@ -318,7 +348,15 @@ export function reducer(state: ChatState, action: ChatAction): ChatState {
             isError: true,
           }))
         : state.messages;
-      return { ...state, isStreaming: false, error: action.message, messages };
+      // Tag the error with the turn it belongs to so its banner survives this
+      // turn's own terminal / trailing chunks / the next user message, and is
+      // retracted only when a strictly newer turn begins. When the error has no
+      // id, fall back to the last streaming placeholder's id (that is the turn
+      // that just failed) so STREAM_CHUNK / STREAM_START can still key off it.
+      const erroredIdx = findLastStreamingIndex(state.messages);
+      const errorTurnId =
+        action.id ?? (erroredIdx === -1 ? null : state.messages[erroredIdx].id);
+      return { ...state, isStreaming: false, error: action.message, errorTurnId, messages };
     }
 
     case 'STREAM_CANCEL_PLACEHOLDER':
@@ -395,13 +433,23 @@ export function reducer(state: ChatState, action: ChatAction): ChatState {
         messages: [],
         isStreaming: false,
         error: null,
+        errorTurnId: null,
       };
 
     case 'ERROR_SET':
       // An error settles the initial load — a failed bootstrap must not leave
       // a stuck spinner; clear `isLoading` and mark the load resolved so the
       // host can fall through to its error/empty surface.
-      return { ...state, error: action.error, isLoading: false, historyLoaded: true };
+      // Bootstrap/host-level error — not tied to a stream turn, so it has no
+      // turn id. Reset any stale tag so a later STREAM_START/CHUNK won't fail to
+      // clear it (or clear it prematurely).
+      return {
+        ...state,
+        error: action.error,
+        errorTurnId: null,
+        isLoading: false,
+        historyLoaded: true,
+      };
 
     case 'ATTACHMENT_PROGRESS': {
       const messages = patchMessageById(state.messages, action.messageId, (m) => {