@ateam-ai-mobile/core 0.1.0

package/src/chat/store.ts

@@ -0,0 +1,938 @@
+/**
+ * Chat store — talks to the ADAS Core API.
+ *
+ * Flow:
+ *   1. loadConversation() → GET /api/conversation → display history
+ *   2. sendMessage(text)  → POST /api/chat { goal } → returns jobId
+ *   3. WebSocket (poll fallback) → real-time progress
+ *   4. When done → GET /api/conversation → formatted response
+ *
+ * Platform notes: no Expo/AsyncStorage imports. Attachment persistence is
+ * delegated to the host via config.attachmentCache; identity and tokens come
+ * from the host via initAdas().
+ */
+import { create } from 'zustand';
+import { getCoreApiUrl, getCoreWsUrl, getToken, getTenant, getUser, getConfig } from '../config';
+import { pluginCommandEmitter } from '../utils/emitter';
+import type { OutgoingAttachment } from '../storage/types';
+import type { Message, MessageAttachment, JobProgress, UIAction } from './types';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface ChatState {
+  messages: Message[];
+  loading: boolean;
+  error: string | null;
+  activeJobId: string | null;
+  conversationLoaded: boolean;
+  /** Load conversation history from Core */
+  loadConversation: () => Promise<void>;
+  /** Send a message via POST /api/chat — creates a job, streams progress */
+  sendMessage: (text: string, skillSlug?: string, attachments?: OutgoingAttachment[]) => Promise<void>;
+  /** Respond to a paused sys.askUser question */
+  respondToQuestion: (jobId: string, inputId: string, answer: string) => Promise<void>;
+  /** Update in-flight job progress (called by the stream handler) */
+  updateJobProgress: (jobId: string, progress: Partial<JobProgress>) => void;
+  /** Reset chat (also re-fetches history on next mount — used on auth switch) */
+  clearChat: () => void;
+  /** Start a fresh empty chat without re-fetching history */
+  newChat: () => void;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function coreHeaders(): Record<string, string> {
+  const token = getToken();
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+  };
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+  return headers;
+}
+
+function isTerminalStatus(status?: unknown): boolean {
+  const s = typeof status === 'string' ? status.toLowerCase() : '';
+  return s === 'done' || s === 'error' || s === 'failed' || s === 'completed';
+}
+
+function normalizeJobStatus(snap: any): JobProgress['status'] {
+  const status = typeof snap?.status === 'string' ? snap.status.toLowerCase() : '';
+  if (status === 'done' || status === 'completed') return 'done';
+  if (status === 'error' || status === 'failed') return 'error';
+  if (status === 'paused' || status === 'waiting') return 'paused';
+  if (status === 'unknown') return 'unknown';
+  return 'running';
+}
+
+function extractPendingQuestion(snap: any): any {
+  return snap?.pendingQuestion || snap?.state?.pendingQuestion || snap?.state?.waiting || null;
+}
+
+function extractActorId(snap: any): string | undefined {
+  const actorId =
+    snap?.actorId ||
+    snap?.actor?.actorId ||
+    snap?.actor?.id ||
+    snap?.state?.actorId ||
+    snap?.state?.actor?.actorId ||
+    snap?.state?.actor?.id;
+  return typeof actorId === 'string' && actorId.length > 0 ? actorId : undefined;
+}
+
+function extractLiveProgress(snap: any): JobProgress['liveProgress'] | undefined {
+  const lp = snap?.liveProgress || snap?.state?.__live_progress;
+  const latest = Array.isArray(lp) ? lp[lp.length - 1] : lp;
+  if (!latest?.message) return undefined;
+  return {
+    message: String(latest.message || ''),
+    ...(latest.step != null ? { step: latest.step } : {}),
+    ...(latest.total != null ? { total: latest.total } : {}),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Extract the most-recently-called tool from job exec steps.
+// snap.state.steps.__exec = { iter_0: [{tool, ok, reason}], iter_1: [...] }
+// ---------------------------------------------------------------------------
+function extractCurrentTool(state: any): string | undefined {
+  const exec = state?.steps?.__exec;
+  if (!exec || typeof exec !== 'object') return undefined;
+  const latest = Object.keys(exec)
+    .map(k => ({ k, n: parseInt(k.replace('iter_', ''), 10) }))
+    .filter(({ n }) => !isNaN(n))
+    .sort((a, b) => b.n - a.n)[0];
+  if (!latest) return undefined;
+  const steps = exec[latest.k];
+  if (!Array.isArray(steps) || !steps.length) return undefined;
+  const last = steps[steps.length - 1];
+  return (last?.tool || last?.phase) as string | undefined;
+}
+
+function snapshotToProgress(snap: any, rootJobId: string): Partial<JobProgress> {
+  const pq = extractPendingQuestion(snap);
+  const progress: Partial<JobProgress> = {
+    jobId: rootJobId,
+    actorId: extractActorId(snap),
+    status: pq ? 'paused' : normalizeJobStatus(snap),
+    subStatus: snap?.subStatus || snap?.phase || snap?.state?.visual?.phase,
+    phase: snap?.phase || snap?.state?.visual?.phase,
+    iteration: snap?.iteration || snap?.state?.plannerIter,
+    skillSlug: snap?.skillSlug || snap?.activeSkill,
+    currentTool: snap?.currentTool || snap?.lastTool || extractCurrentTool(snap?.state),
+  };
+
+  const liveProgress = extractLiveProgress(snap);
+  if (liveProgress) progress.liveProgress = liveProgress;
+
+  if (pq) {
+    progress.pendingQuestion = {
+      inputId: pq.correlation_id || pq.correlationId || pq.inputId || '',
+      question: pq.prompt_message || pq.question || 'The assistant needs your input',
+      inputType: pq.inputType || 'text',
+      options: pq.options || pq.requested_fields,
+      placeholder: pq.placeholder,
+    };
+  }
+
+  return progress;
+}
+
+function isTerminalSnapshot(snap: any): boolean {
+  if (extractPendingQuestion(snap)) return false;
+  return snap?.done === true || isTerminalStatus(snap?.status);
+}
+
+/**
+ * Sentinel delimiters used to embed structured table data inside a flat
+ * message string. UI layers split on these and render the contents with a
+ * native table component instead of markdown tables — markdown tables look
+ * terrible on narrow phone screens.
+ *
+ * Unicode Private Use Area chars (U+E100/U+E101) so they never collide with
+ * anything the model could legitimately emit.
+ */
+export const TABLE_BLOCK_OPEN = '\uE100';
+export const TABLE_BLOCK_CLOSE = '\uE101';
+
+/**
+ * Render a `{ columns: [...], rows: [...] }` payload as a sentinel-wrapped
+ * JSON marker. Returns null if the shape doesn't match.
+ */
+function renderTableShape(content: any): string | null {
+  if (!content || typeof content !== 'object') return null;
+  const cols = Array.isArray(content.columns) ? content.columns : null;
+  const rows = Array.isArray(content.rows) ? content.rows : null;
+  if (!cols || !rows) return null;
+  // encodeURIComponent so the JSON can never contain newlines or sentinel chars.
+  const payload = encodeURIComponent(JSON.stringify({ columns: cols, rows }));
+  return `${TABLE_BLOCK_OPEN}${payload}${TABLE_BLOCK_CLOSE}`;
+}
+
+/**
+ * Extract display text from a conversation turn's assistant blocks.
+ * Handles multiple block kinds (text, code, json, markdown, table, html).
+ */
+export function blocksToText(blocks?: Array<{ kind: string; content: any }>): string {
+  if (!blocks || blocks.length === 0) return '';
+  return blocks.map(b => {
+    if (b.kind === 'text' || b.kind === 'markdown' || b.kind === 'description') {
+      return typeof b.content === 'string' ? b.content : '';
+    }
+    if (b.kind === 'code') {
+      const code = typeof b.content === 'object' ? b.content.content : b.content;
+      return `\`\`\`\n${code}\n\`\`\``;
+    }
+    if (b.kind === 'table' && b.content && typeof b.content === 'object') {
+      const md = renderTableShape(b.content);
+      if (md) return md;
+      // Fall through to generic JSON rendering if shape is unexpected.
+    }
+    if (b.kind === 'json') {
+      // Skip pendingQuestion state objects — internal sys.askUser data
+      if (b.content && typeof b.content === 'object' && 'pendingQuestion' in b.content) return '';
+      // Polisher sometimes wraps tables as kind:'json' when the content has
+      // columns/rows — render those as table blocks too.
+      const md = renderTableShape(b.content);
+      if (md) return md;
+      return '```json\n' + JSON.stringify(b.content, null, 2) + '\n```';
+    }
+    if (b.kind === 'html') {
+      return typeof b.content === 'string' ? b.content : '';
+    }
+    return typeof b.content === 'string' ? b.content : JSON.stringify(b.content);
+  }).filter(Boolean).join('\n\n');
+}
+
+/** Extract image/file attachments from conversation blocks */
+function blocksToAttachments(blocks?: Array<{ kind: string; hash?: string; url?: string; mimeType?: string; name?: string }>): MessageAttachment[] | undefined {
+  if (!blocks || blocks.length === 0) return undefined;
+  const atts: MessageAttachment[] = [];
+  for (const b of blocks) {
+    if ((b.kind === 'image' || b.kind === 'file') && (b.url || b.hash)) {
+      atts.push({
+        mimeType: b.mimeType || (b.kind === 'image' ? 'image/jpeg' : 'application/octet-stream'),
+        name: b.name || 'attachment',
+        previewUri: b.url ? `${getCoreApiUrl()}${b.url}` : undefined,
+      });
+    }
+  }
+  return atts.length > 0 ? atts : undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Store
+// ---------------------------------------------------------------------------
+
+export const useChatStore = create<ChatState>((set, get) => ({
+  messages: [],
+  loading: false,
+  error: null,
+  activeJobId: null,
+  conversationLoaded: false,
+
+  // -----------------------------------------------------------------------
+  // Load conversation history from Core
+  // GET /api/conversation → array of turns [{user, assistant, jobId, ...}]
+  // -----------------------------------------------------------------------
+  loadConversation: async () => {
+    try {
+      const attachmentCache = getConfig().attachmentCache;
+      await attachmentCache?.ready();
+
+      const res = await fetch(`${getCoreApiUrl()}/api/conversation?limit=20`, {
+        headers: coreHeaders(),
+      });
+      if (!res.ok) {
+        console.warn('[adas-chat] Failed to load conversation:', res.status);
+        set({ conversationLoaded: true });
+        return;
+      }
+
+      const data = await res.json();
+      if (!data.ok || !data.items) {
+        set({ conversationLoaded: true });
+        return;
+      }
+
+      // Persisted turns from /api/conversation are the SOLE source of history.
+      // Live job state is mirrored only via WS into the placeholder bubble
+      // created by sendMessage; in-flight local state is preserved below.
+      const items: any[] = [...data.items].reverse();
+      const persistedMessages: Message[] = [];
+      const seenJobIds = new Set<string>();
+      for (const turn of items) {
+        // Deduplicate by jobId (chain jobs can produce duplicate turns)
+        if (turn.jobId && seenJobIds.has(turn.jobId)) continue;
+        if (turn.jobId) seenJobIds.add(turn.jobId);
+
+        // User message
+        const userText = blocksToText(turn.user?.blocks);
+        let userAtts = blocksToAttachments(turn.user?.blocks);
+        // Merge locally cached attachments if API doesn't have them
+        if (!userAtts && turn.jobId) {
+          userAtts = attachmentCache?.get(turn.jobId);
+        }
+        const turnChainId = typeof turn.chainId === 'string' ? turn.chainId : undefined;
+        if (userText || userAtts) {
+          persistedMessages.push({
+            id: `user-${turn.jobId}`,
+            role: 'user',
+            content: userText || '',
+            timestamp: new Date(turn.startedAt || Date.now()),
+            skillSlug: turn.skillSlug,
+            ...(userAtts ? { attachments: userAtts } : {}),
+            ...(turnChainId ? { chainId: turnChainId } : {}),
+          });
+        }
+        // Assistant response
+        const assistantText = blocksToText(turn.assistant?.blocks);
+        const assistantAtts = blocksToAttachments(turn.assistant?.blocks);
+        const assistantActions = Array.isArray(turn.assistant?.actions) ? turn.assistant.actions : undefined;
+        const turnKind = typeof turn.kind === 'string' ? turn.kind : undefined;
+        if (assistantText || assistantAtts || assistantActions?.length) {
+          persistedMessages.push({
+            id: `bot-${turn.jobId}`,
+            role: 'assistant',
+            content: assistantText || '',
+            timestamp: new Date(turn.finishedAt || turn.startedAt || Date.now()),
+            skillSlug: turn.skillSlug,
+            ...(assistantAtts ? { attachments: assistantAtts } : {}),
+            ...(assistantActions?.length ? { actions: assistantActions } : {}),
+            ...(turnChainId ? { chainId: turnChainId } : {}),
+            ...(turnKind ? { kind: turnKind } : {}),
+          });
+        }
+      }
+
+      // Preserve in-flight LOCAL state across pull-to-refresh. /api/conversation
+      // is the truth for HISTORY; anything mid-flight lives only as a local
+      // WS-driven placeholder created by sendMessage.
+      const current = get().messages;
+      const keptPlaceholders: Message[] = [];
+      for (const m of current) {
+        if (!m.id.startsWith('job-') || !m.jobProgress || !m.chainId) continue;
+        const matchIdx = persistedMessages.findIndex(pm =>
+          pm.role === 'assistant' && pm.chainId === m.chainId
+        );
+        if (matchIdx >= 0) {
+          // The persisted turn for this chain has arrived. Move the live
+          // progress overlay (pill) onto it — but only while still in flight.
+          const st = m.jobProgress.status;
+          if (st === 'running' || st === 'paused') {
+            persistedMessages[matchIdx] = { ...persistedMessages[matchIdx], jobProgress: m.jobProgress };
+          }
+          // Drop the placeholder either way.
+        } else {
+          // No persisted turn yet — chain still in flight. Keep it.
+          keptPlaceholders.push(m);
+        }
+      }
+
+      // Optimistic user bubbles (id=`user-<ms>` from sendMessage). Keep until
+      // a persisted user turn arrives. Dedup by chainId — content match has
+      // false positives ("Yes", "Continue", etc.).
+      const isLocalUserId = (id: string) => /^user-\d+$/.test(id);
+      const keptUserBubbles = current.filter(m => {
+        if (m.role !== 'user' || !isLocalUserId(m.id)) return false;
+        if (!m.chainId) return true; // POST in flight — can't dedup yet
+        return !persistedMessages.some(pm =>
+          pm.role === 'user' && pm.chainId === m.chainId
+        );
+      });
+
+      const finalMessages = [...persistedMessages, ...keptUserBubbles, ...keptPlaceholders];
+      finalMessages.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+
+      let firstRunning: Message | undefined = keptPlaceholders.find(m => m.jobProgress?.status === 'running');
+
+      // Cold-start / post-refresh reattach: the WS subscription dies on app
+      // restart. /api/chain/current is the single hydration endpoint that
+      // says "is a chain still in flight for this actor?". If yes, re-open
+      // the live subscription on the same chainId so the pill comes back.
+      try {
+        const chainRes = await fetch(`${getCoreApiUrl()}/api/chain/current`, {
+          headers: coreHeaders(),
+        });
+        if (chainRes.ok) {
+          const chainBody = await chainRes.json();
+          const slim = chainBody?.data;
+          if (slim?.id) {
+            const chainId = String(slim.id);
+            const alreadyTracked = finalMessages.some(m =>
+              m.role === 'assistant' && m.jobProgress?.jobId === chainId
+            );
+            if (!alreadyTracked) {
+              const progress = snapshotToProgress(slim, chainId);
+              const chainCreatedAt = typeof slim.createdAt === 'number'
+                ? slim.createdAt
+                : (typeof slim.lastUpdate === 'number' ? slim.lastUpdate : Date.now());
+              const chainLastUpdate = typeof slim.lastUpdate === 'number' ? slim.lastUpdate : chainCreatedAt;
+              const jobProgress = {
+                jobId: chainId,
+                actorId: extractActorId(slim),
+                status: 'running',
+                chainStartedAt: chainCreatedAt,
+                ...progress,
+              } as JobProgress;
+
+              // Synthesize the user bubble if a hard refresh wiped the
+              // optimistic one and the chain hasn't persisted its turn yet.
+              const goal = typeof slim.goal === 'string' ? slim.goal : '';
+              const userExists = finalMessages.some(m =>
+                m.role === 'user' && (m.chainId === chainId || (goal && m.content === goal))
+              );
+              if (goal && !userExists) {
+                finalMessages.push({
+                  id: `user-${chainId}`,
+                  role: 'user',
+                  content: goal,
+                  timestamp: new Date(chainCreatedAt),
+                  chainId,
+                });
+              }
+
+              // Assistant side: attach to matching persisted turn if one
+              // exists; otherwise push a placeholder bubble.
+              let matchIdx = -1;
+              for (let i = finalMessages.length - 1; i >= 0; i--) {
+                const m = finalMessages[i];
+                if (m.role === 'assistant' && m.chainId === chainId) {
+                  matchIdx = i;
+                  break;
+                }
+              }
+              if (matchIdx >= 0) {
+                finalMessages[matchIdx] = { ...finalMessages[matchIdx], jobProgress };
+                if (jobProgress.status === 'running') firstRunning = finalMessages[matchIdx];
+              } else {
+                const reattachBubble: Message = {
+                  id: `job-${chainId}`,
+                  role: 'assistant',
+                  content: 'Working on it...',
+                  timestamp: new Date(chainLastUpdate),
+                  jobProgress,
+                  chainId,
+                };
+                finalMessages.push(reattachBubble);
+                if (jobProgress.status === 'running') firstRunning = reattachBubble;
+              }
+
+              finalMessages.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+
+              // Re-open the live subscription.
+              streamJob(chainId, getTenant(), getToken());
+            }
+          }
+        }
+      } catch {}
+
+      set({
+        messages: finalMessages,
+        conversationLoaded: true,
+        error: null,
+        activeJobId: firstRunning?.jobProgress?.jobId || null,
+        loading: !!firstRunning,
+      });
+    } catch (err: any) {
+      console.warn('[adas-chat] Error loading conversation:', err.message);
+      set({ conversationLoaded: true });
+    }
+  },
+
+  // -----------------------------------------------------------------------
+  // Send message via Core API
+  // POST /api/chat { goal } → { jobId } → stream → fetch turn result
+  // -----------------------------------------------------------------------
+  sendMessage: async (text: string, skillSlug?: string, attachments?: OutgoingAttachment[]) => {
+    // No `if (loading) return` guard: Chain Additions needs the user to send
+    // WHILE a chain is running. The backend router decides attach/cancel/new.
+
+    const userMsg: Message = {
+      id: `user-${Date.now()}`,
+      role: 'user',
+      content: text,
+      timestamp: new Date(),
+      ...(attachments?.length ? {
+        attachments: attachments.map(a => ({
+          mimeType: a.mimeType,
+          name: a.name,
+          previewUri: a.mimeType.startsWith('image/') ? `data:${a.mimeType};base64,${a.data}` : undefined,
+        }))
+      } : {}),
+    };
+
+    set(s => ({ messages: [...s.messages, userMsg], loading: true, error: null }));
+
+    try {
+      // Backend auto-resolves the skill via conversation continuity → channel
+      // routing → default. triggerContext.channel + replyContext.chatId are
+      // required by handoff-controller-mcp's schema — without them handoffs
+      // fail silently.
+      const actor = getUser();
+      const body: Record<string, unknown> = {
+        goal: text,
+        // Opt in to the Chain Additions router (attach/cancel/new while a
+        // chain runs). Backend ignores it where not applicable — safe to send.
+        chainRouting: true,
+        triggerContext: {
+          channel: 'mobile',
+          replyContext: { chatId: actor?.actorId || 'unknown' },
+        },
+      };
+      if (skillSlug) body.skillSlug = skillSlug;
+      if (attachments?.length) body.attachments = attachments;
+
+      const res = await fetch(`${getCoreApiUrl()}/api/chat`, {
+        method: 'POST',
+        headers: coreHeaders(),
+        body: JSON.stringify(body),
+      });
+
+      if (!res.ok) {
+        let errMsg = `Server error (${res.status})`;
+        try {
+          const text = await res.text();
+          // Don't show raw HTML — extract a short message
+          if (text.startsWith('<') || text.startsWith('<!')) {
+            errMsg = res.status === 502 ? 'Server is temporarily unavailable. Please try again.' : `Server error (${res.status})`;
+          } else {
+            const parsed = JSON.parse(text);
+            errMsg = parsed.error || errMsg;
+          }
+        } catch {}
+        throw new Error(errMsg);
+      }
+
+      const data = await res.json();
+
+      if (!data.ok) {
+        throw new Error(data.error || 'Failed to send message');
+      }
+
+      // Chain Additions: the router may ATTACH this message to the running
+      // chain or CANCEL it. These replies carry NO jobId — handle them and
+      // don't start a second stream.
+      if (data.mode === 'chain_addition' || data.mode === 'chain_cancel') {
+        const ack = data.mode === 'chain_addition'
+          ? (data.ack || 'Got it — added to the running task.')
+          : 'Stopping the task…';
+        set(s => ({
+          messages: s.messages
+            .map(m => (m.id === userMsg.id && data.chainId) ? { ...m, chainId: data.chainId } : m)
+            .concat({
+              id: `ack-${Date.now()}`,
+              role: 'assistant',
+              content: ack,
+              timestamp: new Date(),
+              ...(data.chainId ? { chainId: data.chainId } : {}),
+            }),
+        }));
+        return;
+      }
+
+      const jobId = data.id || data.jobId;
+      if (!jobId) {
+        throw new Error('No job ID returned');
+      }
+
+      // Cache attachments so they survive loadConversation reload. Awaited
+      // intentionally — fire-and-forget can lose the write on quick reload.
+      if (attachments?.length) {
+        await getConfig().attachmentCache?.save(jobId, attachments);
+      }
+
+      // Placeholder assistant bubble = live mirror of the active chain.
+      // Carries chainId so a subsequent loadConversation refresh can adopt
+      // this placeholder's progress. For the root job, chainId == jobId.
+      const progressMsg: Message = {
+        id: `job-${jobId}`,
+        role: 'assistant',
+        content: 'Working on it...',
+        timestamp: new Date(),
+        jobProgress: {
+          jobId,
+          actorId: actor?.actorId,
+          status: 'running',
+          subStatus: 'Starting...',
+          chainStartedAt: Date.now(),
+        },
+        chainId: jobId,
+      };
+
+      // Attach chainId to the optimistic user bubble so loadConversation can
+      // dedup against persisted user turns by chainId.
+      set(s => ({
+        messages: s.messages.map(m =>
+          m.id === userMsg.id ? { ...m, chainId: jobId } : m
+        ).concat(progressMsg),
+        activeJobId: jobId,
+      }));
+
+      // Start streaming for real-time progress
+      streamJob(jobId, getTenant(), getToken());
+    } catch (err: any) {
+      set(s => ({
+        messages: [...s.messages, {
+          id: `error-${Date.now()}`,
+          role: 'system' as const,
+          content: `Error: ${err.message}`,
+          timestamp: new Date(),
+        }],
+        loading: false,
+      }));
+    }
+  },
+
+  // -----------------------------------------------------------------------
+  // Respond to sys.askUser paused question
+  // -----------------------------------------------------------------------
+  respondToQuestion: async (jobId: string, inputId: string, answer: string) => {
+    try {
+      const res = await fetch(`${getCoreApiUrl()}/api/job/${jobId}/respond`, {
+        method: 'POST',
+        headers: coreHeaders(),
+        body: JSON.stringify({ inputId, answer }),
+      });
+      const data = await res.json();
+      if (!data.ok) {
+        console.warn('[adas-chat] Failed to respond to question:', data.error);
+      }
+    } catch (err: any) {
+      console.warn('[adas-chat] Error responding to question:', err.message);
+    }
+  },
+
+  // -----------------------------------------------------------------------
+  // Update job progress (called by the stream handler)
+  // -----------------------------------------------------------------------
+  updateJobProgress: (jobId: string, progress: Partial<JobProgress>) => {
+    set(s => ({
+      messages: s.messages.map(m => {
+        if (m.jobProgress?.jobId === jobId) {
+          const updated = { ...m.jobProgress, ...progress };
+          // Clear pendingQuestion when status is no longer paused
+          if (progress.status && progress.status !== 'paused') {
+            updated.pendingQuestion = undefined;
+          }
+          // Persisted turns (id `bot-…`) own their content/actions from
+          // /api/conversation — the live mirror must never overwrite them.
+          const isPersisted = m.id.startsWith('bot-');
+          const content = isPersisted
+            ? m.content
+            : (progress.resultMessage
+                || progress.pendingQuestion?.question
+                || m.content);
+          const actions = isPersisted
+            ? m.actions
+            : (progress.resultActions?.length ? progress.resultActions : m.actions);
+          return {
+            ...m,
+            jobProgress: updated as JobProgress,
+            content,
+            ...(actions ? { actions } : {}),
+          };
+        }
+        return m;
+      }),
+      loading: (progress.status === 'done' || progress.status === 'error' || progress.status === 'paused')
+        ? false
+        : s.loading,
+      activeJobId: (progress.status === 'done' || progress.status === 'error' || progress.status === 'paused')
+        ? null
+        : s.activeJobId,
+    }));
+  },
+
+  clearChat: () => {
+    set({
+      messages: [],
+      loading: false,
+      error: null,
+      activeJobId: null,
+      conversationLoaded: false,
+    });
+  },
+  newChat: () => {
+    set({
+      messages: [],
+      loading: false,
+      error: null,
+      activeJobId: null,
+      conversationLoaded: true,
+    });
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// WebSocket Streaming — persistent connection, reused across jobs
+// ---------------------------------------------------------------------------
+
+// Track processed plugin command correlationIds to avoid duplicates
+const _processedPluginCmds = new Set<string>();
+
+function dispatchPluginCommands(cmds: any[]) {
+  for (const cmd of cmds) {
+    const corrId = cmd?.correlationId || cmd?.correlation_id;
+    if (corrId && _processedPluginCmds.has(corrId)) continue;
+    if (corrId) _processedPluginCmds.add(corrId);
+
+    pluginCommandEmitter.emit('plugin-command', cmd);
+    const pluginId = cmd?.pluginId || cmd?.plugin_id || cmd?.args?.plugin_id;
+    if (pluginId) {
+      const props = cmd?.props ?? cmd?.args?.props ?? undefined;
+      pluginCommandEmitter.emit('focus-plugin', { pluginId, props });
+    }
+  }
+}
+
+// Persistent WS connection — stays open across jobs
+let _ws: WebSocket | null = null;
+let _wsReady = false;
+let _currentJobId: string | null = null;
+
+function ensureWs(tenant: string, token: string | null): WebSocket {
+  if (_ws && _wsReady) return _ws;
+
+  const wsUrl = `${getCoreWsUrl()}/ws?token=${encodeURIComponent(token || '')}&tenant=${encodeURIComponent(tenant)}`;
+  const ws = new WebSocket(wsUrl);
+  _ws = ws;
+  _wsReady = false;
+
+  ws.onopen = () => {
+    _wsReady = true;
+    // If a job is waiting for the connection, subscribe now
+    if (_currentJobId) {
+      ws.send(JSON.stringify({ type: 'subscribe', jobId: _currentJobId }));
+    }
+  };
+
+  ws.onmessage = (ev) => {
+    try {
+      const msg = JSON.parse(typeof ev.data === 'string' ? ev.data : '');
+      const { event, data } = msg;
+      const { updateJobProgress } = useChatStore.getState();
+      // Route by the event's OWN chain id — the server streams ALL of the
+      // user's active chains down one connection, so each event updates its
+      // own bubble. Fall back to the last-subscribed job for older backends.
+      const jobId = (data && (data.id || data.chainId)) || _currentJobId;
+
+      // Always process plugin_command events even when _currentJobId is null
+      // (e.g., during handoff relay)
+      if (event === 'plugin_command') {
+        dispatchPluginCommands([data]);
+        return;
+      }
+      if (event === 'plugin-command-ack' || event === 'pong') return;
+
+      if (!jobId) return;
+
+      switch (event) {
+        case 'init':
+        case 'job':
+        case 'update': {
+          const snap = data;
+          const progress = snapshotToProgress(snap, jobId);
+
+          if (isTerminalSnapshot(snap)) {
+            // Handoff chain: root job finished but relay job is still running.
+            // The backend broadcasts relay progress as synthetic updates on
+            // this same subscription — stay subscribed and show running.
+            if (snap.status === 'done' && (snap.isHandoff || snap.state?.handoffTransfer)) {
+              updateJobProgress(jobId, { status: 'running' });
+              return;
+            }
+            _currentJobId = null;
+            if (progress.status === 'paused' && progress.pendingQuestion) {
+              updateJobProgress(jobId, progress);
+            } else {
+              fetchTurnResult(jobId, snap);
+            }
+            return;
+          }
+
+          updateJobProgress(jobId, progress);
+          break;
+        }
+        case 'chain_final':
+          // Authoritative chain-termination event (fires once when the WHOLE
+          // chain is done — handoff-forgiven). Preferred over per-job `final`.
+          _currentJobId = null;
+          fetchTurnResult(jobId, data);
+          break;
+        case 'final':
+          _currentJobId = null;
+          fetchTurnResult(jobId, data);
+          break;
+      }
+    } catch (err) {
+      console.warn('[adas-chat] WS parse error:', err);
+    }
+  };
+
+  ws.onerror = () => {
+    _ws = null;
+    _wsReady = false;
+    // Fall back to polling for current job
+    if (_currentJobId) {
+      const jid = _currentJobId;
+      _currentJobId = null;
+      pollJob(jid, token);
+    }
+  };
+
+  ws.onclose = () => {
+    _ws = null;
+    _wsReady = false;
+    if (_currentJobId) {
+      const jid = _currentJobId;
+      _currentJobId = null;
+      pollJob(jid, token);
+    }
+  };
+
+  return ws;
+}
+
+function streamJob(jobId: string, tenant: string, token: string | null) {
+  _currentJobId = jobId;
+  const ws = ensureWs(tenant, token);
+
+  // If WS is already open, subscribe immediately; otherwise onopen handles it
+  if (_wsReady) {
+    ws.send(JSON.stringify({ type: 'subscribe', jobId }));
+  }
+}
+
+/** Tear down the live connection (env/auth switch, SDK unmount). */
+export function closeChatStream(): void {
+  _currentJobId = null;
+  if (_ws) {
+    try { _ws.close(); } catch {}
+  }
+  _ws = null;
+  _wsReady = false;
+}
+
+/**
+ * When a job completes, fetch the conversation turn to get the formatted
+ * response. Falls back to extracting from the job snapshot.
+ */
+async function fetchTurnResult(jobId: string, jobSnap: any) {
+  // Clean up dedup set (cap to prevent unbounded growth)
+  if (_processedPluginCmds.size > 200) _processedPluginCmds.clear();
+  const { updateJobProgress } = useChatStore.getState();
+  const status = normalizeJobStatus(jobSnap) === 'error' ? 'error' : 'done';
+
+  // Handoff chain: if this job handed off, wait for the chain to settle by
+  // polling job status — done:true only when the relay job completes.
+  if (jobSnap.isHandoff || jobSnap.state?.handoffTransfer || jobSnap.result?.contentType === 'handoff') {
+    try {
+      for (let i = 0; i < 40; i++) { // up to ~60s
+        const statusRes = await fetch(`${getCoreApiUrl()}/api/job/${jobId}/status`, {
+          headers: coreHeaders(),
+        });
+        if (statusRes.ok) {
+          const statusData = await statusRes.json();
+          if (statusData.done && !statusData.isHandoff) {
+            break;
+          }
+          updateJobProgress(jobId, { status: 'running' });
+        }
+        await new Promise(r => setTimeout(r, 1500));
+      }
+    } catch {}
+  }
+
+  // Fetch the most recent conversation turn. By actor rather than by jobId,
+  // because handoff chains create child jobs — the real reply lives on the
+  // LAST child, not on the root job we submitted.
+  for (let attempt = 0; attempt < 5; attempt++) {
+    try {
+      const res = await fetch(`${getCoreApiUrl()}/api/conversation?limit=1`, {
+        headers: coreHeaders(),
+      });
+
+      if (res.ok) {
+        const data = await res.json();
+        const items = Array.isArray(data.items) ? data.items : [];
+        const turn = items[0];
+        if (turn?.assistant || turn?.turn?.assistant) {
+          const assistant = turn.assistant || turn.turn?.assistant;
+          const text = blocksToText(assistant.blocks);
+          const actions: UIAction[] | undefined =
+            Array.isArray(assistant.actions) && assistant.actions.length
+              ? assistant.actions
+              : undefined;
+          if (text) {
+            updateJobProgress(jobId, {
+              status,
+              resultMessage: text,
+              ...(actions ? { resultActions: actions } : {}),
+            });
+            return;
+          }
+        }
+      }
+    } catch {}
+    await new Promise(r => setTimeout(r, 800));
+  }
+
+  // Fallback: extract from job snapshot
+  const fallback =
+    jobSnap.result?.message ||
+    jobSnap.state?.finalReply ||
+    (status === 'error' ? 'Something went wrong. Please try again.' : 'Done.');
+
+  updateJobProgress(jobId, { status, resultMessage: fallback });
+}
+
+// ---------------------------------------------------------------------------
+// Polling fallback (when WS is unavailable)
+// ---------------------------------------------------------------------------
+
+async function pollJob(jobId: string, token: string | null) {
+  const { updateJobProgress } = useChatStore.getState();
+
+  for (let i = 0; i < 120; i++) {
+    try {
+      const res = await fetch(`${getCoreApiUrl()}/api/job/${jobId}/status`, {
+        headers: {
+          ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        },
+      });
+
+      if (!res.ok) {
+        if (res.status === 404) return;
+        continue;
+      }
+
+      const snap = await res.json();
+      const progress = snapshotToProgress(snap, jobId);
+
+      // sys.askUser — same logic as the WS handler
+      if (progress.status === 'paused' && progress.pendingQuestion) {
+        updateJobProgress(jobId, progress);
+        return; // Stop polling — waiting for user input
+      }
+
+      updateJobProgress(jobId, progress);
+
+      if (isTerminalSnapshot(snap)) {
+        fetchTurnResult(jobId, snap);
+        return;
+      }
+    } catch {}
+
+    await new Promise(r => setTimeout(r, 1500));
+  }
+
+  // Timeout
+  updateJobProgress(jobId, {
+    status: 'error',
+    resultMessage: 'Job timed out. Please try again.',
+  });
+}