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

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

@@ -0,0 +1,141 @@
+import type { AgentResourceReference } from '@vertesia/common';
+import { Badge, Button, cn } from '@vertesia/ui/core';
+import { useUITranslation } from '@vertesia/ui/i18n';
+import { NavLink } from '@vertesia/ui/router';
+import { useAgentResourceResolver } from '@vertesia/ui/widgets';
+import { getResourceActionVariant, getResourceIcon } from './resourceLinks';
+
+interface ResourceChipProps {
+    resource: AgentResourceReference;
+    /** Originating run, passed to the resolver for run-scoped resources. */
+    workflowRunId?: string;
+    /** Hide the action badge when surrounding text already communicates the action. */
+    showAction?: boolean;
+    className?: string;
+}
+
+/**
+ * A compact resource chip for something an agent tool created/updated/deleted. The host resolver may
+ * make it navigable (NavLink applies tenant sticky params), activate a host callback, or leave it
+ * non-interactive.
+ */
+export function ResourceChip({ resource, workflowRunId, showAction = true, className }: ResourceChipProps) {
+    const { t } = useUITranslation();
+    const resolve = useAgentResourceResolver();
+    const target = resolve(resource, { workflowRunId, source: 'structured' });
+    const Icon = getResourceIcon(resource.type);
+    // Literal keys (not a dynamic lookup) so i18next-cli can statically extract them.
+    const actionLabel =
+        resource.action === 'created'
+            ? t('agent.resourceActionCreated')
+            : resource.action === 'deleted'
+              ? t('agent.resourceActionDeleted')
+              : t('agent.resourceActionUpdated');
+
+    const body = (
+        <>
+            <Icon className="size-3.5 shrink-0 text-foreground" aria-hidden="true" />
+            <span className="truncate">{resource.label}</span>
+            {showAction && (
+                <Badge variant={getResourceActionVariant(resource.action)} className="shrink-0 px-1.5 py-0 text-[10px]">
+                    {actionLabel}
+                </Badge>
+            )}
+        </>
+    );
+
+    const baseClass = cn(
+        'inline-flex max-w-full items-center gap-1.5 rounded-md border border-border bg-background px-2 py-1 text-xs',
+        className,
+    );
+
+    if (target.kind === 'navigate') {
+        return (
+            <NavLink
+                href={target.href}
+                topLevelNav
+                className={cn(baseClass, 'font-medium transition-colors hover:bg-muted/60')}
+            >
+                {body}
+            </NavLink>
+        );
+    }
+
+    if (target.kind === 'activate') {
+        return (
+            <Button
+                variant="unstyled"
+                onClick={target.onActivate}
+                className={cn(baseClass, 'font-medium transition-colors hover:bg-muted/60')}
+            >
+                {body}
+            </Button>
+        );
+    }
+
+    // Deleted or unresolvable resource: no navigation target, render a non-interactive chip.
+    return <span className={cn(baseClass, 'text-muted')}>{body}</span>;
+}
+
+interface ResourceActivityLinkListProps {
+    resources: AgentResourceReference[];
+    workflowRunId?: string;
+    className?: string;
+}
+
+/** Inline action + deep-link presentation for completed tool timeline rows. */
+export function ResourceActivityLinkList({ resources, workflowRunId, className }: ResourceActivityLinkListProps) {
+    const { t } = useUITranslation();
+    if (resources.length === 0) return null;
+
+    return (
+        <div
+            className={cn('flex min-w-0 flex-wrap items-center gap-x-2 gap-y-1', className)}
+            data-agent-resource-activity
+        >
+            {resources.map((resource) => {
+                const actionLabel =
+                    resource.action === 'created'
+                        ? t('agent.resourceActionCreated')
+                        : resource.action === 'deleted'
+                          ? t('agent.resourceActionDeleted')
+                          : t('agent.resourceActionUpdated');
+                return (
+                    <span
+                        key={`${resource.type}:${resource.id}:${resource.action}`}
+                        className="inline-flex min-w-0 items-center gap-1.5"
+                    >
+                        <span className="shrink-0 text-sm text-muted">{actionLabel}</span>
+                        <ResourceChip
+                            resource={resource}
+                            workflowRunId={workflowRunId}
+                            showAction={false}
+                            className="py-0.5"
+                        />
+                    </span>
+                );
+            })}
+        </div>
+    );
+}
+
+interface ResourceChipListProps {
+    resources: AgentResourceReference[];
+    workflowRunId?: string;
+    className?: string;
+}
+
+export function ResourceChipList({ resources, workflowRunId, className }: ResourceChipListProps) {
+    if (resources.length === 0) return null;
+    return (
+        <div className={cn('flex flex-wrap gap-1.5', className)}>
+            {resources.map((resource) => (
+                <ResourceChip
+                    key={`${resource.type}:${resource.id}:${resource.action}`}
+                    resource={resource}
+                    workflowRunId={workflowRunId}
+                />
+            ))}
+        </div>
+    );
+}

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/requestInputMessages.test.ts

@@ -0,0 +1,80 @@
+import { type AgentMessage, AgentMessageType } from '@vertesia/common';
+import { describe, expect, it } from 'vitest';
+import {
+    getAnsweredToolApprovalRequestInputKeys,
+    getRequestInputMessageKey,
+    getToolApprovalResponseMetadata,
+} from './requestInputMessages';
+
+const APPROVAL_KEY = 'create_interaction:name:JDE AR Payment Processing Agent';
+
+function makeApprovalRequest(): AgentMessage {
+    return {
+        timestamp: 1,
+        type: AgentMessageType.REQUEST_INPUT,
+        message: 'Approve Create a new draft interaction: JDE AR Payment Processing Agent?',
+        workstream_id: 'main',
+        details: {
+            tool_approval: { tool_name: 'create_interaction', approval_key: APPROVAL_KEY },
+            ux: { options: [{ id: 'allow_once' }, { id: 'allow_for_run' }, { id: 'deny' }] },
+        },
+    } as unknown as AgentMessage;
+}
+
+function makeUserAnswer(message: string, metadata?: Record<string, unknown>): AgentMessage {
+    return {
+        timestamp: 2,
+        type: AgentMessageType.QUESTION,
+        message,
+        workstream_id: 'main',
+        details: metadata ? { metadata } : undefined,
+    } as unknown as AgentMessage;
+}
+
+describe('getToolApprovalResponseMetadata', () => {
+    it('builds structured response metadata for approval options', () => {
+        expect(getToolApprovalResponseMetadata(makeApprovalRequest(), 'allow_for_run')).toEqual({
+            tool_approval_response: { decision: 'allow_for_run', approval_key: APPROVAL_KEY },
+        });
+    });
+
+    it('returns undefined for prompts that are not tool approvals', () => {
+        const plainPrompt = {
+            timestamp: 1,
+            type: AgentMessageType.REQUEST_INPUT,
+            message: 'Which environment?',
+            workstream_id: 'main',
+            details: { ux: { options: [{ id: 'staging' }, { id: 'production' }] } },
+        } as unknown as AgentMessage;
+        expect(getToolApprovalResponseMetadata(plainPrompt, 'staging')).toBeUndefined();
+    });
+
+    it('returns undefined for unknown option ids', () => {
+        expect(getToolApprovalResponseMetadata(makeApprovalRequest(), 'staging')).toBeUndefined();
+    });
+});
+
+describe('getAnsweredToolApprovalRequestInputKeys', () => {
+    it('treats a bare option answer as answered', () => {
+        const request = makeApprovalRequest();
+        const answer = makeUserAnswer('allow_for_run');
+        const answered = getAnsweredToolApprovalRequestInputKeys([request, answer]);
+        expect(answered.has(getRequestInputMessageKey(request))).toBe(true);
+    });
+
+    it('treats a metadata-carrying answer as answered regardless of its text', () => {
+        const request = makeApprovalRequest();
+        const answer = makeUserAnswer('Allow this action for this run\n\nUploaded artifacts:\n[a.png](artifact:a)', {
+            tool_approval_response: { decision: 'allow_for_run', approval_key: APPROVAL_KEY },
+        });
+        const answered = getAnsweredToolApprovalRequestInputKeys([request, answer]);
+        expect(answered.has(getRequestInputMessageKey(request))).toBe(true);
+    });
+
+    it('does not treat unrelated prose as an approval answer', () => {
+        const request = makeApprovalRequest();
+        const answer = makeUserAnswer('please proceed\n\nUploaded artifacts:\n[a.png](artifact:a)');
+        const answered = getAnsweredToolApprovalRequestInputKeys([request, answer]);
+        expect(answered.size).toBe(0);
+    });
+});

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

@@ -169,6 +169,22 @@ export function isToolApprovalRequestInput(message: AgentMessage): boolean {
     return message.type === AgentMessageType.REQUEST_INPUT && getToolApprovalKey(message) !== undefined;
 }
 
+const TOOL_APPROVAL_OPTION_DECISIONS = new Set(['allow_once', 'allow_for_run', 'deny']);
+
+/**
+ * Metadata to attach when the user picks an option on a tool-approval prompt, so the workflow
+ * reads the decision structurally instead of from the message text (which clients may decorate,
+ * e.g. with an attachments footer). Returns undefined for non-approval prompts or unknown options.
+ */
+export function getToolApprovalResponseMetadata(
+    message: AgentMessage,
+    optionId: string,
+): Record<string, unknown> | undefined {
+    const approvalKey = getToolApprovalKey(message);
+    if (!approvalKey || !TOOL_APPROVAL_OPTION_DECISIONS.has(optionId)) return undefined;
+    return { tool_approval_response: { decision: optionId, approval_key: approvalKey } };
+}
+
 function isToolApprovalOptionResponse(message: AgentMessage): boolean {
     if (message.type !== AgentMessageType.QUESTION) return false;
     const normalized = getAgentMessageText(message).trim().toLowerCase();
@@ -181,7 +197,11 @@ function isToolApprovalMetadataResponse(message: AgentMessage): boolean {
     const metadata = getRecord(details?.metadata);
     const toolApprovalResponse =
         getRecord(details?.tool_approval_response) ?? getRecord(metadata?.tool_approval_response);
-    return toolApprovalResponse?.decision === 'deny_with_feedback';
+    const decision = toolApprovalResponse?.decision;
+    return (
+        decision === 'deny_with_feedback' ||
+        (typeof decision === 'string' && TOOL_APPROVAL_OPTION_DECISIONS.has(decision))
+    );
 }
 
 function isToolApprovalResponse(message: AgentMessage): boolean {

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);
+    });
+});