@flamingo-stack/openframe-frontend-core 0.0.583 → 0.0.584-1973.5420.1

package/src/components/chat/__tests__/tool-execution-display.test.tsx

@@ -0,0 +1,93 @@
+import { render, screen } from '@testing-library/react';
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
+import { decodeNatsChunk } from '../../../chat-protocol/nats-decoder';
+import { createChatStreamReducer } from '../stream/chat-stream-reducer';
+import { ToolExecutionDisplay } from '../tool-execution-display';
+import type { ToolExecutionData } from '../types';
+
+const execution = (overrides: Partial<ToolExecutionData>): ToolExecutionData => ({
+  type: 'EXECUTING_TOOL',
+  integratedToolType: 'OPENFRAME',
+  toolFunction: 'search_docs',
+  ...overrides,
+});
+
+beforeAll(() => {
+  vi.stubGlobal(
+    'ResizeObserver',
+    class {
+      observe(): void {}
+      disconnect(): void {}
+      unobserve(): void {}
+    },
+  );
+});
+
+afterAll(() => {
+  vi.unstubAllGlobals();
+});
+
+describe('ToolExecutionDisplay remote read activity', () => {
+  it('keeps a completed remote read concise through the real wire pipeline', () => {
+    const reducer = createChatStreamReducer({ transport: 'nats' });
+    for (const chunk of [
+      {
+        type: 'EXECUTING_TOOL',
+        integratedToolType: null,
+        toolFunction: 'remote_read',
+        title: 'Searching product documentation',
+        parameters: null,
+        toolExecutionRequestId: 'remote-read-1',
+      },
+      {
+        type: 'EXECUTED_TOOL',
+        integratedToolType: null,
+        toolFunction: 'remote_read',
+        result: null,
+        success: true,
+        toolExecutionRequestId: 'remote-read-1',
+      },
+    ]) {
+      const event = decodeNatsChunk(chunk);
+      if (event) reducer.apply(event);
+    }
+    const toolSegment = reducer.state.messages
+      .flatMap(message => message.segments ?? [])
+      .find(segment => segment.type === 'tool_execution');
+
+    expect(toolSegment?.type).toBe('tool_execution');
+    if (toolSegment?.type !== 'tool_execution') return;
+    render(<ToolExecutionDisplay message={toolSegment.data} />);
+
+    expect(screen.getByText('Searching product documentation')).toBeInTheDocument();
+    expect(screen.queryByRole('button')).not.toBeInTheDocument();
+    expect(screen.queryByText('Remote read')).not.toBeInTheDocument();
+  });
+
+  it('keeps a typed local tool expandable when its body is absent', () => {
+    render(
+      <ToolExecutionDisplay
+        message={execution({
+          integratedToolType: 'OPENFRAME',
+          toolTitle: 'Refresh device inventory',
+        })}
+      />,
+    );
+
+    expect(screen.getByRole('button')).toBeInTheDocument();
+  });
+
+  it('keeps a backend-described remote read concise while running', () => {
+    render(
+      <ToolExecutionDisplay
+        message={execution({
+          integratedToolType: undefined,
+          toolTitle: 'Searching product documentation',
+        })}
+      />,
+    );
+
+    expect(screen.getByText('Searching product documentation')).toBeInTheDocument();
+    expect(screen.queryByRole('button')).not.toBeInTheDocument();
+  });
+});

package/src/components/chat/chat-message-enhanced.tsx

@@ -103,6 +103,7 @@ const ChatMessageEnhanced = forwardRef<HTMLDivElement, ChatMessageEnhancedProps>
       renderContextItem,
       renderMention,
       renderEntityCard,
+      refs,
       onAskSelect,
       NavLinkAnchor,
       ...props
@@ -127,6 +128,11 @@ const ChatMessageEnhanced = forwardRef<HTMLDivElement, ChatMessageEnhancedProps>
     // literal `[card://...]` URL.
     const hasMarkerSupport = !!renderEntityCard;
 
+    const refsByKey = useMemo(
+      () => new Map((refs ?? []).map(reference => [`${reference.type}:${reference.id}`, reference])),
+      [refs],
+    );
+
     const segments = useMemo(() => normalizeContent(content), [content]);
 
     const askRuns = useMemo(() => groupAskRuns(segments), [segments]);
@@ -180,7 +186,14 @@ const ChatMessageEnhanced = forwardRef<HTMLDivElement, ChatMessageEnhancedProps>
     // (and its open menu) survives across chunks. Invalidated per key when the
     // render fn identity changes.
     const renderedCardNodeCache = useRef(
-      new Map<string, { render: ((ref: ChatRef) => React.ReactNode) | undefined; node: React.ReactNode }>(),
+      new Map<
+        string,
+        {
+          render: ((ref: ChatRef) => React.ReactNode) | undefined;
+          reference: ChatRef;
+          node: React.ReactNode;
+        }
+      >(),
     );
 
     /**
@@ -242,10 +255,17 @@ const ChatMessageEnhanced = forwardRef<HTMLDivElement, ChatMessageEnhancedProps>
           // menu / re-fetching) on every stream chunk. Also dedups the same
           // key emitted twice within one message.
           let entry = cache.get(key);
-          if (!entry || entry.render !== render) {
-            // The marker is the ONLY data on the wire: cards hydrate by id
-            // from the host's per-object APIs, so a minimal {type, id}
-            // descriptor is all the renderer needs to mount the loader.
+          const enrichedRef = refsByKey.get(key);
+          const refForRender: ChatRef = enrichedRef ?? {
+            type: cardType,
+            id: cardId,
+            title: cardId,
+            url: null,
+          };
+          if (!entry || entry.render !== render || entry.reference !== refForRender) {
+            // Prefer same-turn SOURCES metadata when available. Otherwise
+            // cards hydrate by id from the host's per-object APIs, so a
+            // minimal {type, id} descriptor still mounts the loader.
             // For types with nothing to fetch the host's render() returns
             // null and we fall through to the bare-cardId fallback in the
             // `<a card://…>` override below.
@@ -257,13 +277,7 @@ const ChatMessageEnhanced = forwardRef<HTMLDivElement, ChatMessageEnhancedProps>
             // the id rather than `undefined`) and `url` to null (matches
             // the no-link semantics fetch-mode cards rely on — they
             // resolve their own URL after fetch).
-            const refForRender: ChatRef = {
-              type: cardType,
-              id: cardId,
-              title: cardId,
-              url: null,
-            };
-            entry = { render, node: render(refForRender) };
+            entry = { render, reference: refForRender, node: render(refForRender) };
             cache.set(key, entry);
           }
           const rendered = entry.node;
@@ -326,7 +340,7 @@ const ChatMessageEnhanced = forwardRef<HTMLDivElement, ChatMessageEnhancedProps>
         }
       });
       return { inlineByKey, partsBySegment, usedKeys };
-    }, [hasMarkerSupport, renderEntityCard, segments]);
+    }, [hasMarkerSupport, refsByKey, renderEntityCard, segments]);
 
     // Drop cached nodes for markers no longer present so the cache can't grow
     // unbounded as a long message's markers change. Deliberately an EFFECT,
@@ -716,6 +730,7 @@ const MemoizedChatMessageEnhanced = memo(ChatMessageEnhanced, (prevProps, nextPr
     // equality holds across streaming chunks.
     prevProps.renderMention === nextProps.renderMention &&
     prevProps.renderEntityCard === nextProps.renderEntityCard &&
+    prevProps.refs === nextProps.refs &&
     // Same stability contract as the renderers above: hosts pass a `useCallback`
     // (EmbeddableChat passes its memoized `handleSend`), so this holds across
     // streaming chunks instead of re-rendering every ask card per chunk.

package/src/components/chat/chat-message-list.tsx

@@ -1005,6 +1005,7 @@ const ChatMessageList = forwardRef<HTMLDivElement, ChatMessageListProps>(
                       renderContextItem={renderContextItem}
                       renderMention={renderMention}
                       renderEntityCard={renderEntityCard}
+                      refs={message.refs}
                       onAskSelect={index > lastUserMessageIndex ? onAskSelect : undefined}
                       NavLinkAnchor={NavLinkAnchor}
                     />

package/src/components/chat/embeddable-chat.tsx

@@ -1579,6 +1579,10 @@ function EmbeddableChatInner({
         // explicitly — see `Message.hidden` and `chat-message-list`'s skip.
         ...(m.hidden ? { hidden: true } : {}),
         ...(m.scrollAnchor ? { scrollAnchor: m.scrollAnchor } : {}),
+        // Preserve same-turn rich metadata. Source chips and entity-card
+        // renderers consume it after this raw-to-Message projection.
+        ...(m.sources && m.sources.length > 0 ? { sources: m.sources } : {}),
+        ...(m.refs && m.refs.length > 0 ? { refs: m.refs } : {}),
         // Forward attached context items so the user bubble renders its chips.
         ...(m.contextItems && m.contextItems.length > 0 ? { contextItems: m.contextItems } : {}),
       };
@@ -1835,7 +1839,12 @@ function EmbeddableChatInner({
     if (chatLoading) return undefined;
     const sources = lastAssistantMsg?.sources;
     if (!sources || sources.length === 0) return undefined;
-    const content = lastAssistantMsg?.content || '';
+    const content =
+      lastAssistantMsg.content ||
+      (lastAssistantMsg.segments ?? [])
+        .filter(segment => segment.type === 'text')
+        .map(segment => segment.text)
+        .join('\n');
     const citationOrder = [...content.matchAll(/\[(\d+)\]/g)].map(m => parseInt(m[1], 10));
     const seenOrder = new Map<number, number>();
     citationOrder.forEach(idx => {

package/src/components/chat/entity-cards/__tests__/dispatch-video-refs.test.tsx

@@ -0,0 +1,74 @@
+import React from 'react';
+import { describe, expect, it } from 'vitest';
+import type { ChatRef } from '../../chat-ref.types';
+import { BlockCard } from '../block-card';
+import { ChatVideoEntityCard } from '../chat-video-entity-card';
+import { renderChatInlineEntityCard } from '../dispatch';
+
+describe('renderChatInlineEntityCard video refs', () => {
+  it.each([
+    {
+      id: 'MdFJNoJeqZQ',
+      url: 'https://www.youtube.com/watch?v=MdFJNoJeqZQ',
+      metadata: { youtubeUrl: 'MdFJNoJeqZQ' },
+    },
+    {
+      id: 'mux-9b6586b494',
+      url: 'https://stream.mux.com/playback-id.m3u8',
+      metadata: { videoUrl: 'https://stream.mux.com/playback-id.m3u8' },
+    },
+    {
+      id: 'mp4-1b2047dc1b',
+      url: 'https://cdn.example.test/product-overview.mp4',
+      metadata: { videoUrl: 'https://cdn.example.test/product-overview.mp4' },
+    },
+  ])('passes playable metadata for $id to the video card', ({ id, url, metadata }) => {
+    const ref: ChatRef = { type: 'video', id, title: 'Video', url, metadata };
+
+    const result = renderChatInlineEntityCard(ref);
+
+    expect(React.isValidElement(result)).toBe(true);
+    const block = result as React.ReactElement<React.ComponentProps<typeof BlockCard>>;
+    expect(block.type).toBe(BlockCard);
+    const video = block.props.children as React.ReactElement<React.ComponentProps<typeof ChatVideoEntityCard>>;
+    expect(video.type).toBe(ChatVideoEntityCard);
+    expect(video.props.chatRef.metadata).toMatchObject(metadata);
+  });
+
+  it('lets a validated top-level URL override conflicting route metadata', () => {
+    const ref: ChatRef = {
+      type: 'video',
+      id: 'mux-9b6586b494',
+      title: 'Video',
+      url: 'https://stream.mux.com/trusted-playback.m3u8',
+      metadata: {
+        videoUrl: 'https://cdn.example.test/untrusted.mp4',
+        youtubeUrl: 'untrustedId',
+      },
+    };
+
+    const result = renderChatInlineEntityCard(ref);
+    const block = result as React.ReactElement<React.ComponentProps<typeof BlockCard>>;
+    const video = block.props.children as React.ReactElement<React.ComponentProps<typeof ChatVideoEntityCard>>;
+
+    expect(video.props.chatRef.metadata).toEqual({
+      videoUrl: 'https://stream.mux.com/trusted-playback.m3u8',
+    });
+  });
+
+  it('keeps a direct-video URL direct when its query mentions a YouTube URL', () => {
+    const directUrl = 'https://cdn.example.test/product-overview.mp4?source=youtube.com/watch?v=MdFJNoJeqZQ';
+    const ref: ChatRef = {
+      type: 'video',
+      id: 'mp4-direct',
+      title: 'Product overview',
+      url: directUrl,
+    };
+
+    const result = renderChatInlineEntityCard(ref);
+    const block = result as React.ReactElement<React.ComponentProps<typeof BlockCard>>;
+    const video = block.props.children as React.ReactElement<React.ComponentProps<typeof ChatVideoEntityCard>>;
+
+    expect(video.props.chatRef.metadata).toEqual({ videoUrl: directUrl });
+  });
+});

package/src/components/chat/entity-cards/dispatch.tsx

@@ -41,6 +41,7 @@ import {
   formatTimeWithTimezone,
   formatDurationFromRange,
 } from '../../../utils/format';
+import { extractYouTubeId } from '../../features/video';
 import { MingoIcon } from '../../icons';
 import { ArrowRightUpIcon } from '../../icons-v2-generated/arrows/arrow-right-up-icon';
 import { ClickupLogoIcon } from '../../icons-v2-generated/brand-logos/clickup-logo-icon';
@@ -422,6 +423,15 @@ function hubspotStatusToVariant(status: string | undefined): MingoInfoCardStatus
  * which renders the marker as plain text (same anti-hallucination
  * posture as every other card type).
  */
+function validatedHttpsUrl(value: unknown): string | null {
+  if (typeof value !== 'string') return null;
+  try {
+    return new URL(value).protocol === 'https:' ? value : null;
+  } catch {
+    return null;
+  }
+}
+
 function decodeVideoMarkerId(id: string): { videoUrl?: string; youtubeUrl?: string } | null {
   // Prefix checks FIRST: an id like `mux-1234567` (11 chars) would also
   // satisfy the bare-YouTube-id pattern below.
@@ -439,8 +449,8 @@ function decodeVideoMarkerId(id: string): { videoUrl?: string; youtubeUrl?: stri
       const url = atob(b64);
       // https-only — the id is model-emitted text; never let a marker
       // smuggle a non-https src into a player.
-      if (!/^https:\/\//.test(url)) return null;
-      return { videoUrl: url };
+      const safeUrl = validatedHttpsUrl(url);
+      return safeUrl ? { videoUrl: safeUrl } : null;
     } catch {
       return null;
     }
@@ -449,6 +459,29 @@ function decodeVideoMarkerId(id: string): { videoUrl?: string; youtubeUrl?: stri
   return null;
 }
 
+function validatedVideoMetadata(chatRef: ChatRef): Record<string, unknown> | null {
+  const input = chatRef.metadata ?? {};
+  const metadata: Record<string, unknown> = {};
+  for (const key of ['videoUrl', 'highlightVideoUrl', 'videoPoster', 'highlightVideoPoster'] as const) {
+    const url = validatedHttpsUrl(input[key]);
+    if (url) metadata[key] = url;
+  }
+  const youtubeUrl = input.youtubeUrl;
+  if (typeof youtubeUrl === 'string' && /^[A-Za-z0-9_-]{11}$/.test(youtubeUrl)) {
+    metadata.youtubeUrl = youtubeUrl;
+  }
+
+  const safeUrl = validatedHttpsUrl(chatRef.url);
+  if (safeUrl) {
+    const youtubeId = extractYouTubeId(safeUrl);
+    delete metadata.videoUrl;
+    delete metadata.youtubeUrl;
+    metadata[youtubeId ? 'youtubeUrl' : 'videoUrl'] = youtubeId ?? safeUrl;
+  }
+
+  return Object.keys(metadata).length > 0 ? metadata : null;
+}
+
 /** Read hero-video metadata off a FETCHED item — the API-driven
  *  replacement for the retired refs-frame `metadata.videoUrl` check. Two item
  *  shapes: ChatRef-shaped items (per-object hydration routes) carry the
@@ -1983,24 +2016,28 @@ export function renderChatInlineEntityCard(
     />
   );
 
-  // Embedded videos are SELF-DESCRIBING: the marker id alone recovers the
-  // playable URL (`decodeVideoMarkerId`), so the player renders on ANY
-  // transport with zero refs/fetch. Undecodable ids (legacy sha1 hashes,
-  // hallucinations) fall through to the loader → plain-text degrade.
+  // SOURCES metadata may enrich an opaque video marker with its playable URL.
+  // Self-describing marker ids remain transport-independent through
+  // `decodeVideoMarkerId`; undecodable ids without matching metadata fall
+  // through to the loader and degrade to plain text.
   // Hero videos on FETCHED entity types (webinars, releases, …) are
   // handled post-fetch inside ChatCardLoader (`itemVideoMetadata`) — the
-  // marker's ref plays no part in either path.
+  // marker metadata is not required for that post-fetch path.
   if (chatRef.type === 'video') {
+    const enrichedMetadata = validatedVideoMetadata(chatRef);
     const decoded = decodeVideoMarkerId(chatRef.id);
-    if (decoded) {
+    const playableMetadata = enrichedMetadata ?? decoded;
+    if (playableMetadata) {
       const displayRef: ChatRef = {
         ...chatRef,
         title: chatRef.title && chatRef.title !== chatRef.id ? chatRef.title : 'Video',
         url:
           chatRef.url ??
-          decoded.videoUrl ??
-          (decoded.youtubeUrl ? `https://www.youtube.com/watch?v=${decoded.youtubeUrl}` : null),
-        metadata: { ...(chatRef.metadata ?? {}), ...decoded },
+          (typeof playableMetadata.videoUrl === 'string' ? playableMetadata.videoUrl : null) ??
+          (typeof playableMetadata.youtubeUrl === 'string'
+            ? `https://www.youtube.com/watch?v=${playableMetadata.youtubeUrl}`
+            : null),
+        metadata: playableMetadata,
       };
       return (
         <BlockCard inline={<ChatInlineVideoPill chatRef={displayRef} />}>

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

@@ -61,6 +61,7 @@ import type {
   MessageSegment,
   NatsMessageType,
   ChatApprovalStatus,
+  ChatSource,
 } from '../types';
 import type { DialogItem } from '../types/component.types';
 import type {
@@ -352,6 +353,8 @@ export function mapProcessedToUnified(
     role: 'user' | 'assistant' | 'error';
     content: string | MessageSegment[];
     name?: string;
+    sources?: ChatSource[];
+    refs?: ChatRef[];
   }>,
 ): UnifiedChatMessage[] {
   const out: UnifiedChatMessage[] = [];
@@ -363,12 +366,16 @@ export function mapProcessedToUnified(
         role: m.role,
         content: '',
         segments: m.content,
+        ...(m.sources ? { sources: m.sources } : {}),
+        ...(m.refs ? { refs: m.refs } : {}),
       });
     } else {
       out.push({
         id: m.id,
         role: m.role,
         content: m.content,
+        ...(m.sources ? { sources: m.sources } : {}),
+        ...(m.refs ? { refs: m.refs } : {}),
       });
     }
   }

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

@@ -63,7 +63,7 @@ import type { ChatDialogStore } from '../stream/chat-dialog-store';
 import type { ChatStreamReducerOptions } from '../stream/chat-stream-reducer';
 import { useChatStreamReducer } from '../stream/use-chat-stream-reducer';
 import type { DialogItem } from '../types/component.types';
-import type { Message, MessageSegment } from '../types/message.types';
+import type { ChatSource, Message, MessageSegment } from '../types/message.types';
 import type {
   UnifiedChatState,
   UnifiedChatMessage,
@@ -81,6 +81,7 @@ import { useSlashCommandRegistry, type SlashCommandSummary } from './use-slash-c
 // Canonical home of the per-turn meta row moved to the stream module in
 // Phase 3; re-exported here to keep the legacy import path stable.
 export type { ChatTurnMeta } from '../stream/chat-stream-reducer';
+export type { ChatSource } from '../types/message.types';
 
 // ─── Stable no-op references for the Guide-mode dialog-management stubs ──
 // Plain module-scope constants so the adapter's return identity stays
@@ -128,34 +129,6 @@ const noopBumpMetaTick = (): void => {};
  *  hub-side platform-utils, not in lib). */
 export type DocSource = string;
 
-export interface ChatSource {
-  index: number;
-  name: string;
-  path: string;
-  documentType: string;
-  externalUrl?: string;
-  /** Platform that owns the destination at `externalUrl`. */
-  targetPlatform?: string | null;
-  /** Primary-key value for single-row chips. */
-  id?: string;
-  /** Per-row items for grouped chips. */
-  items?: Array<{
-    id: string;
-    documentType: string;
-    name: string;
-    externalUrl?: string;
-    targetPlatform?: string | null;
-    /** In-app doc-tree path for markdown / data-room-doc rows so the
-     *  grouped chip's anchor can trigger an in-page doc-tree swap via
-     *  `handleChatNavClick` (parity with single-row chips + cards). */
-    path?: string | null;
-  }>;
-  /** RagTableConfig.id for this source. */
-  sourceRepo?: string;
-  /** Optional display label override returned by the chat API. */
-  label?: string;
-}
-
 export interface DocChatMessage {
   id: string;
   role: 'user' | 'assistant';

package/src/components/chat/stream/__tests__/chat-stream-reducer.test.ts

@@ -1289,3 +1289,59 @@ describe('createChatStreamReducer — ask cards', () => {
     expect(last.segments?.map(s => s.type)).toEqual(['ask', 'ask']);
   });
 });
+
+describe('createChatStreamReducer — Mingo source metadata', () => {
+  const sources = [
+    {
+      index: 1,
+      name: 'Enroll devices',
+      path: 'docs/enroll.md',
+      documentType: 'markdown',
+    },
+  ];
+
+  it('attaches metadata received before text to the same assistant turn', () => {
+    const reducer = createChatStreamReducer({ transport: 'nats' });
+    const refs = [
+      {
+        type: 'video',
+        id: 'mux-9b6586b494',
+        title: 'Community demo',
+        url: 'https://stream.mux.com/playback-id.m3u8',
+        metadata: { videoUrl: 'https://stream.mux.com/playback-id.m3u8' },
+      },
+    ];
+
+    reducer.apply({ type: 'turn-start', seq: 1 });
+    reducer.apply({ type: 'sources', sources, refs, seq: 2 });
+    reducer.apply({ type: 'text-delta', text: 'Follow the guide [1].', seq: 3 });
+
+    expect(reducer.state.messages).toHaveLength(1);
+    expect(reducer.state.messages[0]).toMatchObject({ sources, refs });
+  });
+
+  it('deduplicates cumulative metadata and does not leak it into the next turn', () => {
+    const reducer = createChatStreamReducer({ transport: 'nats' });
+
+    reducer.apply({ type: 'turn-start', seq: 1 });
+    reducer.apply({ type: 'sources', sources, seq: 2 });
+    reducer.apply({
+      type: 'sources',
+      sources: [
+        { ...sources[0], name: 'Duplicate' },
+        { index: 2, name: 'Install agent', path: 'docs/install.md', documentType: 'markdown' },
+      ],
+      seq: 3,
+    });
+    reducer.apply({ type: 'text-delta', text: 'First answer [1] [2].', seq: 4 });
+    reducer.apply({ type: 'turn-end', seq: 5 });
+    reducer.apply({ type: 'turn-start', seq: 6 });
+    reducer.apply({ type: 'text-delta', text: 'Second answer.', seq: 7 });
+
+    expect(reducer.state.messages[0].sources).toEqual([
+      sources[0],
+      { index: 2, name: 'Install agent', path: 'docs/install.md', documentType: 'markdown' },
+    ]);
+    expect(reducer.state.messages[1].sources).toBeUndefined();
+  });
+});

package/src/components/chat/stream/chat-stream-reducer.ts

@@ -60,6 +60,7 @@ import {
   type ParticipantEvent,
   type UsageEvent,
 } from '../../../chat-protocol/events';
+import type { ChatRef } from '../chat-ref.types';
 import type {
   ApprovalBatchSegment,
   ApprovalRequestSegment,
@@ -70,6 +71,7 @@ import type {
   ToolExecutionSegment,
   ExecutingToolState,
 } from '../types';
+import type { ChatSource } from '../types/message.types';
 import type { PendingApproval } from '../types/processing.types';
 import type {
   DialogTokenUsage,
@@ -78,6 +80,7 @@ import type {
   UnifiedUsageBreakdown,
 } from '../types/unified-chat-state.types';
 import { approvalDisplaysInline } from '../utils/approval-display';
+import { mergeChatRefs, mergeChatSources } from '../utils/chat-source-metadata';
 import {
   type MessageSegmentAccumulator,
   createMessageSegmentAccumulator,
@@ -676,6 +679,9 @@ export function createChatStreamReducer(options: ChatStreamReducerOptions = {}):
   let sendCount = 0;
   let sseCurrentText = '';
 
+  let pendingSources: ChatSource[] | undefined;
+  let pendingRefs: ChatRef[] | undefined;
+
   // ── Snapshot cache ─────────────────────────────────────────────────────
   let stateCache: ChatReducerState | null = null;
   function invalidate(): void {
@@ -773,6 +779,18 @@ export function createChatStreamReducer(options: ChatStreamReducerOptions = {}):
     setMessagesInternal(stampTrailingAssistantSeq(updateTrailingAssistant(messages, segments), seq));
   }
 
+  function attachPendingSourceMetadata(): void {
+    if (!pendingSources && !pendingRefs) return;
+    const last = messages[messages.length - 1];
+    if (!last || last.role !== 'assistant') return;
+    const next = {
+      ...last,
+      ...(pendingSources ? { sources: pendingSources } : {}),
+      ...(pendingRefs ? { refs: pendingRefs } : {}),
+    };
+    setMessagesInternal([...messages.slice(0, -1), next]);
+  }
+
   function applyStreamStartToState(): void {
     setPhaseInternal('streaming');
     // A new stream must never overwrite a COMPLETED trailing assistant
@@ -966,6 +984,8 @@ export function createChatStreamReducer(options: ChatStreamReducerOptions = {}):
 
     switch (event.type) {
       case 'turn-start': {
+        pendingSources = undefined;
+        pendingRefs = undefined;
         isInStream = true;
         hasEverStreamed = true;
         turnStartedAt = Date.now();
@@ -981,6 +1001,15 @@ export function createChatStreamReducer(options: ChatStreamReducerOptions = {}):
         emit('onStreamEnd');
         setPhaseInternal('idle');
         accumulator.resetSegments();
+        pendingSources = undefined;
+        pendingRefs = undefined;
+        break;
+      }
+
+      case 'sources': {
+        pendingSources = mergeChatSources(pendingSources, event.sources);
+        if (event.refs) pendingRefs = mergeChatRefs(pendingRefs, event.refs);
+        attachPendingSourceMetadata();
         break;
       }
 
@@ -1017,10 +1046,12 @@ export function createChatStreamReducer(options: ChatStreamReducerOptions = {}):
         if (isInStream || !hasEverStreamed) {
           emitSegments(segments);
           applySegmentsToState(segments, withSeqMeta(undefined));
+          attachPendingSourceMetadata();
         } else {
           const delta: MessageSegment[] = [{ type: kind, text: event.text }];
           emitSegments(delta, { append: true });
           applySegmentsToState(delta, withSeqMeta({ append: true }));
+          attachPendingSourceMetadata();
         }
         break;
       }

package/src/components/chat/tool-execution-display.tsx

@@ -54,6 +54,9 @@ const ToolExecutionDisplay = forwardRef<HTMLDivElement, ToolExecutionDisplayProp
 
     const hasResult = isExecuted && typeof message.result === 'string' && message.result.length > 0;
     const hasBody = argEntries.length > 0 || hasResult || isExecuting;
+    const isConciseRemoteRead =
+      !message.integratedToolType && !!message.toolTitle?.trim() && argEntries.length === 0 && !hasResult;
+    const isStaticRow = isClientView || isConciseRemoteRead;
 
     const renderStatusIcon = () => {
       if (isExecuting) return <DotsLoaderIcon size={16} className="text-ods-text-secondary" />;
@@ -82,7 +85,7 @@ const ToolExecutionDisplay = forwardRef<HTMLDivElement, ToolExecutionDisplayProp
           {previewText}
         </div>
         <div className="flex h-5 w-5 shrink-0 items-center justify-center">{renderStatusIcon()}</div>
-        {!isClientView && (
+        {!isStaticRow && (
           <div className="flex h-5 w-5 shrink-0 items-center justify-center">
             <ExpandChevron expanded={expanded} />
           </div>
@@ -101,7 +104,7 @@ const ToolExecutionDisplay = forwardRef<HTMLDivElement, ToolExecutionDisplayProp
         )}
         {...props}
       >
-        {isClientView ? (
+        {isStaticRow ? (
           // Client (Fae end-user): static, non-expandable row — no chevron, no
           // body. Just the explanation + status; command/args/result are hidden.
           <div className="flex w-full items-start gap-[var(--spacing-system-xs)] p-[var(--spacing-system-s)] text-left">

package/src/components/chat/types/component.types.ts

@@ -195,6 +195,8 @@ export interface ChatMessageEnhancedProps extends Omit<HTMLAttributes<HTMLDivEle
    * back to plain text title-only.
    */
   renderEntityCard?: (reference: ChatRef) => ReactNode;
+  /** Enriched references associated with this assistant answer. */
+  refs?: ChatRef[];
   /**
    * Host-provided anchor component for markdown links. When supplied, the
    * `<a>` override in the markdown renderer delegates to this component