@vertesia/ui 1.5.0-dev.20260722.120446Z → 1.5.0-dev.20260725.083715Z

package/src/features/agent/chat/ModernAgentOutput/ToolCallGroup.tsx

@@ -1,4 +1,9 @@
-import { type AgentMessage, AgentMessageType } from '@vertesia/common';
+import {
+    type AgentMessage,
+    AgentMessageType,
+    type AgentResourceReference,
+    getResourcesFromMessage,
+} from '@vertesia/common';
 import { Button, cn, onActivateKey, useToast } from '@vertesia/ui/core';
 import { useUITranslation } from '@vertesia/ui/i18n';
 import { useUserSession } from '@vertesia/ui/session';
@@ -9,6 +14,7 @@ import { memo, useEffect, useMemo, useRef, useState } from 'react';
 import { PulsatingCircle } from '../AnimatedThinkingDots';
 import { useImageLightbox } from '../ImageLightbox';
 import { getArtifactCacheKey, useArtifactUrlCache } from '../useArtifactUrlCache.js';
+import { ResourceChipList } from './ResourceChip';
 import type { ToolExecutionStatus } from './utils';
 
 /** Keys that are internal metadata and not interesting to display */
@@ -27,8 +33,10 @@ const META_KEYS = new Set([
     'files',
     'outputFiles',
     'display_role',
+    'duration_ms',
     'observation',
     'progress_messages',
+    'resources',
     'browseruse',
     'browser_use',
 ]);
@@ -797,6 +805,23 @@ function ToolCallGroupComponent({
     // Extract workflow_run_id from messages (any message in the group should have it)
     const artifactRunId = messages.find((m) => m.workflow_run_id)?.workflow_run_id ?? messages[0]?.workflow_run_id;
 
+    // Aggregate resource references across the whole group so deep links stay visible even when the
+    // group is collapsed (mirrors how group images/files are surfaced at the group level).
+    const groupResources = useMemo(() => {
+        const seen = new Set<string>();
+        const out: AgentResourceReference[] = [];
+        for (const m of messages) {
+            for (const ref of getResourcesFromMessage(m)) {
+                const key = `${ref.type}:${ref.id}:${ref.action}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    out.push(ref);
+                }
+            }
+        }
+        return out;
+    }, [messages]);
+
     // Render status indicator based on tool execution status
     const renderStatusIndicator = () => {
         // Only pulse for the currently active/latest group
@@ -966,6 +991,13 @@ function ToolCallGroupComponent({
             {/* Show all images from the group prominently at the top */}
             <GroupImageDisplay messages={messages} artifactRunId={artifactRunId} />
 
+            {/* Deep links to resources created/updated/deleted in this group, independent of expansion state. */}
+            {groupResources.length > 0 && (
+                <div className="px-4 pt-1 pb-2">
+                    <ResourceChipList resources={groupResources} workflowRunId={artifactRunId} />
+                </div>
+            )}
+
             {/* Collapsed summary - show tool calls as single-line rows with expand option */}
             {isCollapsed && (
                 <div className="px-3 py-0.5 space-y-0">

package/src/features/agent/chat/ModernAgentOutput/resourceLinks.tsx

@@ -0,0 +1,43 @@
+import type { AgentResourceAction, AgentResourceType } from '@vertesia/common';
+import type { LucideIcon } from 'lucide-react';
+import {
+    Boxes,
+    BrainCircuit,
+    Database,
+    FileType,
+    MessagesSquare,
+    PanelsTopLeft,
+    PlayCircle,
+    SquareTerminal,
+    Workflow,
+} from 'lucide-react';
+
+const RESOURCE_ICONS: Record<AgentResourceType, LucideIcon> = {
+    document: Database,
+    collection: Boxes,
+    content_type: FileType,
+    interaction: MessagesSquare,
+    prompt: SquareTerminal,
+    agent: BrainCircuit,
+    workflow: Workflow,
+    process: Workflow,
+    process_run: PlayCircle,
+    interaction_run: PlayCircle,
+    view: PanelsTopLeft,
+};
+
+export function getResourceIcon(type: AgentResourceType): LucideIcon {
+    return RESOURCE_ICONS[type];
+}
+
+/** Badge variant for a resource action, using the semantic color system. */
+export function getResourceActionVariant(action: AgentResourceAction): 'success' | 'info' | 'outline' {
+    switch (action) {
+        case 'created':
+            return 'success';
+        case 'deleted':
+            return 'outline';
+        default:
+            return 'info';
+    }
+}

package/src/features/agent/chat/ModernAgentOutput/resourceSummary.test.ts

@@ -0,0 +1,229 @@
+import { type AgentMessage, AgentMessageType, type AgentResourceReference } from '@vertesia/common';
+import { describe, expect, it } from 'vitest';
+import {
+    aggregateLatestTurnResources,
+    interleaveTurnSummaries,
+    isResourceSummaryReady,
+    segmentTurnResources,
+} from './resourceSummary';
+
+let seq = 0;
+function msg(type: AgentMessageType, resources?: AgentResourceReference[], workstream_id = 'main'): AgentMessage {
+    seq += 1;
+    return {
+        timestamp: seq,
+        workflow_run_id: 'run-1',
+        type,
+        message: '',
+        workstream_id,
+        ...(resources ? { details: { event_class: 'activity', resources } } : {}),
+    };
+}
+
+function ref(
+    type: AgentResourceReference['type'],
+    id: string,
+    action: AgentResourceReference['action'],
+    label = id,
+): AgentResourceReference {
+    return { type, id, label, action };
+}
+
+describe('aggregateLatestTurnResources', () => {
+    it('returns resources from tool messages in the latest turn', () => {
+        const result = aggregateLatestTurnResources([
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('document', 'd1', 'created', 'Doc One')]),
+            msg(AgentMessageType.THOUGHT, [ref('collection', 'c1', 'created', 'Col One')]),
+            msg(AgentMessageType.COMPLETE),
+        ]);
+        expect(result).toEqual([
+            ref('document', 'd1', 'created', 'Doc One'),
+            ref('collection', 'c1', 'created', 'Col One'),
+        ]);
+    });
+
+    it('ignores resources from earlier turns', () => {
+        const result = aggregateLatestTurnResources([
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('document', 'old', 'created')]),
+            msg(AgentMessageType.COMPLETE),
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('document', 'new', 'created')]),
+            msg(AgentMessageType.COMPLETE),
+        ]);
+        expect(result).toEqual([ref('document', 'new', 'created')]);
+    });
+
+    it('dedupes by (type, id) and lets create win over later updates', () => {
+        const result = aggregateLatestTurnResources([
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('document', 'd1', 'created', 'First')]),
+            msg(AgentMessageType.THOUGHT, [ref('document', 'd1', 'updated', 'Renamed')]),
+        ]);
+        // create wins, but the most recent label is retained
+        expect(result).toEqual([ref('document', 'd1', 'created', 'Renamed')]);
+    });
+
+    it('drops a resource created then deleted in the same turn', () => {
+        const result = aggregateLatestTurnResources([
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('document', 'scratch', 'created')]),
+            msg(AgentMessageType.THOUGHT, [ref('document', 'scratch', 'deleted')]),
+        ]);
+        expect(result).toEqual([]);
+    });
+
+    it('keeps a resource deleted then re-created in the same turn (order matters)', () => {
+        const result = aggregateLatestTurnResources([
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('view', 'v1', 'deleted')]),
+            msg(AgentMessageType.THOUGHT, [ref('view', 'v1', 'created', 'Rebuilt View')]),
+        ]);
+        expect(result).toEqual([ref('view', 'v1', 'created', 'Rebuilt View')]);
+    });
+
+    it('reports a pre-existing resource deleted → recreated → deleted as deleted (not transient)', () => {
+        const result = aggregateLatestTurnResources([
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('view', 'v1', 'deleted')]),
+            msg(AgentMessageType.THOUGHT, [ref('view', 'v1', 'created')]),
+            msg(AgentMessageType.THOUGHT, [ref('view', 'v1', 'deleted', 'Old View')]),
+        ]);
+        expect(result).toEqual([ref('view', 'v1', 'deleted', 'Old View')]);
+    });
+
+    it('omits a resource created → deleted → created → deleted (never existed before the turn)', () => {
+        const result = aggregateLatestTurnResources([
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('view', 'v1', 'created')]),
+            msg(AgentMessageType.THOUGHT, [ref('view', 'v1', 'deleted')]),
+            msg(AgentMessageType.THOUGHT, [ref('view', 'v1', 'created')]),
+            msg(AgentMessageType.THOUGHT, [ref('view', 'v1', 'deleted')]),
+        ]);
+        expect(result).toEqual([]);
+    });
+
+    it('keeps a delete of a pre-existing resource', () => {
+        const result = aggregateLatestTurnResources([
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('interaction', 'i1', 'deleted', 'Old Interaction')]),
+        ]);
+        expect(result).toEqual([ref('interaction', 'i1', 'deleted', 'Old Interaction')]);
+    });
+
+    it('collapses repeated updates into a single entry', () => {
+        const result = aggregateLatestTurnResources([
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('collection', 'c1', 'updated')]),
+            msg(AgentMessageType.THOUGHT, [ref('collection', 'c1', 'updated')]),
+        ]);
+        expect(result).toEqual([ref('collection', 'c1', 'updated')]);
+    });
+
+    it('aggregates resources across child workstreams in the turn', () => {
+        const result = aggregateLatestTurnResources([
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('document', 'main-doc', 'created')], 'main'),
+            msg(AgentMessageType.THOUGHT, [ref('document', 'child-doc', 'created')], 'ws-2'),
+        ]);
+        expect(result).toEqual([ref('document', 'main-doc', 'created'), ref('document', 'child-doc', 'created')]);
+    });
+});
+
+describe('segmentTurnResources', () => {
+    it('returns one entry per turn with that turn’s resources', () => {
+        const turns = segmentTurnResources([
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('document', 'd1', 'created')]),
+            msg(AgentMessageType.COMPLETE),
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('collection', 'c1', 'created')]),
+            msg(AgentMessageType.COMPLETE),
+        ]);
+        expect(turns).toEqual([[ref('document', 'd1', 'created')], [ref('collection', 'c1', 'created')]]);
+    });
+
+    it('folds leading non-question messages into the first turn (index alignment)', () => {
+        const turns = segmentTurnResources([
+            msg(AgentMessageType.SYSTEM),
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('document', 'd1', 'created')]),
+            msg(AgentMessageType.QUESTION),
+            msg(AgentMessageType.THOUGHT, [ref('document', 'd2', 'created')]),
+        ]);
+        expect(turns).toHaveLength(2);
+        expect(turns[0]).toEqual([ref('document', 'd1', 'created')]);
+        expect(turns[1]).toEqual([ref('document', 'd2', 'created')]);
+    });
+});
+
+describe('isResourceSummaryReady', () => {
+    it('treats a final answer as the end of an interactive turn', () => {
+        expect(
+            isResourceSummaryReady([
+                msg(AgentMessageType.QUESTION),
+                msg(AgentMessageType.THOUGHT, [ref('document', 'd1', 'created')]),
+                msg(AgentMessageType.ANSWER),
+            ]),
+        ).toBe(true);
+    });
+
+    it('does not treat an answer as final when later main-workstream activity exists', () => {
+        expect(
+            isResourceSummaryReady([
+                msg(AgentMessageType.QUESTION),
+                msg(AgentMessageType.ANSWER),
+                msg(AgentMessageType.THOUGHT),
+            ]),
+        ).toBe(false);
+    });
+
+    it('does not let a child-workstream answer complete the main turn', () => {
+        expect(
+            isResourceSummaryReady([
+                msg(AgentMessageType.QUESTION),
+                msg(AgentMessageType.THOUGHT),
+                msg(AgentMessageType.ANSWER, undefined, 'child'),
+            ]),
+        ).toBe(false);
+    });
+});
+
+describe('interleaveTurnSummaries', () => {
+    type Item = { kind: 'q' | 'x'; id: string };
+    const q = (id: string): Item => ({ kind: 'q', id });
+    const x = (id: string): Item => ({ kind: 'x', id });
+    const isBoundary = (i: Item) => i.kind === 'q';
+    const turn = (id: string, action: AgentResourceReference['action'] = 'created'): AgentResourceReference[] => [
+        ref('document', id, action),
+    ];
+
+    it('inserts a completed turn’s summary before the next turn boundary and at the end', () => {
+        const items = [q('q1'), x('a'), q('q2'), x('b')];
+        const out = interleaveTurnSummaries(items, isBoundary, [turn('d1'), turn('d2')], true);
+        const kinds = out.map((i) => ('type' in i ? i.type : i.kind));
+        // summary for turn 0 appears before q2; summary for turn 1 at the end
+        expect(kinds).toEqual(['q', 'x', 'resource_summary', 'q', 'x', 'resource_summary']);
+    });
+
+    it('does not render the last (in-progress) turn summary until the stream is complete', () => {
+        const items = [q('q1'), x('a')];
+        const out = interleaveTurnSummaries(items, isBoundary, [turn('d1')], false);
+        expect(out.some((i) => 'type' in i && i.type === 'resource_summary')).toBe(false);
+    });
+
+    it('skips turns with no resources', () => {
+        const items = [q('q1'), x('a'), q('q2')];
+        const empty: AgentResourceReference[] = [];
+        const out = interleaveTurnSummaries(items, isBoundary, [empty, turn('d2')], true);
+        // turn 0 empty → no summary before q2; turn 1 has resources → summary at end
+        const kinds = out.map((i) => ('type' in i ? i.type : i.kind));
+        expect(kinds).toEqual(['q', 'x', 'q', 'resource_summary']);
+    });
+
+    it('returns items unchanged when there are no turn summaries', () => {
+        const items = [q('q1'), x('a')];
+        expect(interleaveTurnSummaries(items, isBoundary, [], true)).toBe(items);
+    });
+});

package/src/features/agent/chat/ModernAgentOutput/resourceSummary.ts

@@ -0,0 +1,152 @@
+import {
+    type AgentMessage,
+    AgentMessageType,
+    type AgentResourceReference,
+    getResourcesFromMessage,
+} from '@vertesia/common';
+import { getWorkstreamId, isInProgress } from './utils';
+
+interface ResourceAccumulator {
+    ref: AgentResourceReference;
+    /** The first action observed for this resource in the turn — indicates whether it pre-existed. */
+    firstAction: AgentResourceReference['action'];
+    /** The most recent action observed, in message order. */
+    lastAction: AgentResourceReference['action'];
+    /** True once a `created` action was seen for this resource within the turn. */
+    createdInTurn: boolean;
+}
+
+/**
+ * Dedupe the resources referenced across a set of messages by (type, id), modeling operations
+ * sequentially (in message order):
+ * - first created then finally deleted (create → … → delete) → transient scratch work that never
+ *   existed before the turn, omitted;
+ * - a resource that pre-existed (first action was delete/update) and ends deleted → kept as `deleted`
+ *   (e.g. delete → create → delete reports `deleted`, not transient);
+ * - any sequence ending in create, or containing a create when not ending deleted → kept as `created`;
+ * - otherwise `updated`.
+ * The most recently seen label/revision is retained, and first-mention order is preserved.
+ */
+function dedupeResources(messages: AgentMessage[]): AgentResourceReference[] {
+    const order: string[] = [];
+    const byKey = new Map<string, ResourceAccumulator>();
+
+    for (const message of messages) {
+        for (const ref of getResourcesFromMessage(message)) {
+            const key = `${ref.type}:${ref.id}`;
+            let entry = byKey.get(key);
+            if (!entry) {
+                entry = { ref, firstAction: ref.action, lastAction: ref.action, createdInTurn: false };
+                byKey.set(key, entry);
+                order.push(key);
+            }
+            entry.ref = ref;
+            entry.lastAction = ref.action;
+            if (ref.action === 'created') entry.createdInTurn = true;
+        }
+    }
+
+    const result: AgentResourceReference[] = [];
+    for (const key of order) {
+        const entry = byKey.get(key);
+        if (!entry) continue;
+        // Created first and ultimately deleted → never existed before the turn, transient: omit.
+        if (entry.firstAction === 'created' && entry.lastAction === 'deleted') continue;
+        const action: AgentResourceReference['action'] =
+            entry.lastAction === 'deleted'
+                ? 'deleted'
+                : entry.lastAction === 'created' || entry.createdInTurn
+                  ? 'created'
+                  : 'updated';
+        result.push({ ...entry.ref, action });
+    }
+    return result;
+}
+
+/**
+ * Split the conversation into turns at user QUESTION boundaries and return the deduped resources for
+ * each turn, in order. A turn spans from one user message up to (but excluding) the next. Turns with
+ * no resources still produce an entry (empty list) so callers can align positions with turn indices.
+ */
+export function segmentTurnResources(messages: AgentMessage[]): AgentResourceReference[][] {
+    if (messages.length === 0) return [];
+    const turns: AgentMessage[][] = [];
+    let current: AgentMessage[] = [];
+    let currentHasQuestion = false;
+    for (const message of messages) {
+        // Start a new turn at each user QUESTION, but fold any leading non-question messages (e.g. an
+        // initial system prompt) into the first turn so turn indices align with QUESTION order.
+        if (message.type === AgentMessageType.QUESTION && currentHasQuestion) {
+            turns.push(current);
+            current = [];
+            currentHasQuestion = false;
+        }
+        if (message.type === AgentMessageType.QUESTION) currentHasQuestion = true;
+        current.push(message);
+    }
+    if (current.length > 0) turns.push(current);
+
+    return turns.map(dedupeResources);
+}
+
+/**
+ * Aggregate the resources created/updated/deleted during the most recent turn. Convenience wrapper
+ * over {@link segmentTurnResources} for callers that only need the latest turn.
+ */
+export function aggregateLatestTurnResources(messages: AgentMessage[]): AgentResourceReference[] {
+    const turns = segmentTurnResources(messages);
+    return turns.length > 0 ? turns[turns.length - 1] : [];
+}
+
+/**
+ * Whether the latest main-workstream turn has produced its final response and its resource summary
+ * can be shown. Interactive conversations commonly remain alive after an ANSWER so they can accept
+ * another user message; requiring the entire workflow to become terminal would hide the summary for
+ * those otherwise-complete turns.
+ */
+export function isResourceSummaryReady(messages: AgentMessage[]): boolean {
+    if (!isInProgress(messages)) return true;
+
+    const mainMessages = messages.filter((message) => getWorkstreamId(message) === 'main');
+    const lastMainMessage = mainMessages[mainMessages.length - 1];
+    return lastMainMessage?.type === AgentMessageType.ANSWER;
+}
+
+export interface ResourceSummaryRenderItem {
+    type: 'resource_summary';
+    key: string;
+    resources: AgentResourceReference[];
+}
+
+/**
+ * Interleave per-turn resource summaries into a rendered timeline of `items`. A completed turn's
+ * summary is emitted right before the next turn begins, and the most recent completed turn's summary
+ * at the end. `isTurnBoundary` identifies the user-message item that starts a new turn; the i-th
+ * boundary maps to `turnResources[i - 1]`. The final (most recent) turn is only summarized when
+ * `isLatestTurnComplete` is true, so an in-progress turn shows no summary. Empty turns are skipped.
+ */
+export function interleaveTurnSummaries<T>(
+    items: T[],
+    isTurnBoundary: (item: T) => boolean,
+    turnResources: AgentResourceReference[][],
+    isLatestTurnComplete: boolean,
+): Array<T | ResourceSummaryRenderItem> {
+    if (turnResources.length === 0) return items;
+    const out: Array<T | ResourceSummaryRenderItem> = [];
+    const pushSummary = (turnIndex: number) => {
+        const resources = turnResources[turnIndex];
+        if (!resources || resources.length === 0) return;
+        const isLastTurn = turnIndex >= turnResources.length - 1;
+        if (isLastTurn && !isLatestTurnComplete) return;
+        out.push({ type: 'resource_summary', key: `resource-summary-${turnIndex}`, resources });
+    };
+    let boundariesSeen = 0;
+    for (const item of items) {
+        const boundary = isTurnBoundary(item);
+        if (boundary && boundariesSeen > 0) pushSummary(boundariesSeen - 1);
+        if (boundary) boundariesSeen += 1;
+        out.push(item);
+    }
+    pushSummary(boundariesSeen > 0 ? boundariesSeen - 1 : turnResources.length - 1);
+    return out;
+}

package/src/features/agent/chat/ModernAgentOutput/utils.test.ts

@@ -154,6 +154,23 @@ describe('ModernAgentOutput utils - progress state', () => {
 
         expect(isInProgress([idle, question])).toBe(true);
     });
+
+    it('ignores passive artifact working-copy saves after the agent goes idle', () => {
+        const idle = makeMessage({
+            timestamp: 1000,
+            type: AgentMessageType.IDLE,
+            message: 'Waiting for your command...',
+        });
+        const userAutosave = makeMessage({
+            timestamp: 2000,
+            type: AgentMessageType.UPDATE,
+            message: 'Updated working copy files/blog_post_draft.md',
+            details: { event_class: 'artifact_updated', source: 'user_edit', generation: '1784609448394436' },
+        });
+
+        // The user editing their artifact while the agent is idle must not resurrect "Working".
+        expect(isInProgress([idle, userAutosave])).toBe(false);
+    });
 });
 
 describe('ModernAgentOutput utils - sliding view thinking', () => {

package/src/features/agent/chat/ModernAgentOutput/utils.ts

@@ -55,6 +55,19 @@ export const DONE_STATES = [
     AgentMessageType.TERMINATED,
 ];
 
+/**
+ * Passive artifact working-copy saves (e.g. the user autosaving their edits in the collaborative
+ * editor) arrive as UPDATE messages with an `artifact_updated` event class. They are not agent
+ * activity: they must not flip the conversation back to "Working" and must not render as tool-call
+ * cards in the timeline.
+ */
+export function isPassiveArtifactUpdate(message: AgentMessage): boolean {
+    return (
+        message.type === AgentMessageType.UPDATE &&
+        (message.details as { event_class?: string } | undefined)?.event_class === 'artifact_updated'
+    );
+}
+
 export function isInProgress(messages: AgentMessage[]) {
     if (!messages.length) return true;
 
@@ -63,7 +76,7 @@ export function isInProgress(messages: AgentMessage[]) {
         message.details?._deliveryStatus === 'failed' &&
         DONE_STATES.includes(message.type);
 
-    const progressMessages = messages.filter((m) => !isTerminalOptimisticFailure(m));
+    const progressMessages = messages.filter((m) => !isTerminalOptimisticFailure(m) && !isPassiveArtifactUpdate(m));
 
     // Only the main workstream determines whether the conversation is in progress.
     // Child workstream COMPLETE/IDLE messages must not flip this flag.