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

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

@@ -0,0 +1,148 @@
+// @vitest-environment jsdom
+
+import { cleanup, fireEvent, render, screen } from '@testing-library/react';
+import type { AgentResourceReference } from '@vertesia/common';
+import {
+    Boxes,
+    BrainCircuit,
+    Database,
+    FileType,
+    MessagesSquare,
+    PanelsTopLeft,
+    PlayCircle,
+    SquareTerminal,
+    Workflow,
+} from 'lucide-react';
+import type React from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { I18nProvider } from '../../../../i18n/index.js';
+import { ReactRouterContext, type RouterContext } from '../../../../router/index.js';
+import { AgentResourceResolverProvider } from '../../../../widgets/markdown/AgentResourceResolver';
+import { ResourceChangeSummary } from './ResourceChangeSummary';
+import { ResourceChip } from './ResourceChip';
+import { getResourceIcon } from './resourceLinks';
+
+function makeRouterContext(): RouterContext {
+    return {
+        location: window.location,
+        route: { path: '/', Component: () => null },
+        params: {},
+        state: null,
+        matchedRoutePath: '/',
+        navigate: vi.fn(),
+        router: {
+            navigate: vi.fn(),
+            getTopRouter: () => ({ navigator: { addStickyParams: (href: string) => href } }),
+        },
+    } as unknown as RouterContext;
+}
+
+function renderWithProviders(ui: React.ReactNode) {
+    return render(
+        <I18nProvider lng="en">
+            <ReactRouterContext.Provider value={makeRouterContext()}>{ui}</ReactRouterContext.Provider>
+        </I18nProvider>,
+    );
+}
+
+const ref = (over: Partial<AgentResourceReference> = {}): AgentResourceReference => ({
+    type: 'document',
+    id: 'd1',
+    label: 'My Document',
+    action: 'created',
+    ...over,
+});
+
+afterEach(() => cleanup());
+
+describe('ResourceChip', () => {
+    it('uses the same icons as the Studio navigation', () => {
+        expect(getResourceIcon('document')).toBe(Database);
+        expect(getResourceIcon('collection')).toBe(Boxes);
+        expect(getResourceIcon('content_type')).toBe(FileType);
+        expect(getResourceIcon('interaction')).toBe(MessagesSquare);
+        expect(getResourceIcon('prompt')).toBe(SquareTerminal);
+        expect(getResourceIcon('agent')).toBe(BrainCircuit);
+        expect(getResourceIcon('workflow')).toBe(Workflow);
+        expect(getResourceIcon('process')).toBe(Workflow);
+        expect(getResourceIcon('process_run')).toBe(PlayCircle);
+        expect(getResourceIcon('interaction_run')).toBe(PlayCircle);
+        expect(getResourceIcon('view')).toBe(PanelsTopLeft);
+    });
+
+    it('renders a navigable link supplied by the host resolver', () => {
+        renderWithProviders(
+            <AgentResourceResolverProvider value={() => ({ kind: 'navigate', href: '/documents/d1' })}>
+                <ResourceChip resource={ref()} />
+            </AgentResourceResolverProvider>,
+        );
+        const link = screen.getByRole('link', { name: /My Document/ });
+        expect(link.getAttribute('href')).toContain('/documents/d1');
+        expect(screen.getByText('Created')).not.toBeNull();
+    });
+
+    it('renders a non-interactive chip when the host does not configure a resolver', () => {
+        renderWithProviders(<ResourceChip resource={ref({ type: 'interaction', id: 'int-1', label: 'Chat' })} />);
+        expect(screen.queryByRole('link')).toBeNull();
+        expect(screen.getByText('Chat')).not.toBeNull();
+    });
+
+    it('renders a deleted resource as a non-interactive chip (no link)', () => {
+        renderWithProviders(<ResourceChip resource={ref({ action: 'deleted', label: 'Gone' })} />);
+        expect(screen.queryByRole('link')).toBeNull();
+        expect(screen.getByText('Gone')).not.toBeNull();
+        expect(screen.getByText('Deleted')).not.toBeNull();
+    });
+
+    it('honors a resolver override from context', () => {
+        renderWithProviders(
+            <AgentResourceResolverProvider value={() => ({ kind: 'navigate', href: '/custom/path' })}>
+                <ResourceChip resource={ref()} />
+            </AgentResourceResolverProvider>,
+        );
+        expect(screen.getByRole('link').getAttribute('href')).toContain('/custom/path');
+    });
+
+    it('supports a host activation callback instead of navigation', () => {
+        const onActivate = vi.fn();
+        renderWithProviders(
+            <AgentResourceResolverProvider value={() => ({ kind: 'activate', onActivate })}>
+                <ResourceChip resource={ref()} />
+            </AgentResourceResolverProvider>,
+        );
+
+        fireEvent.click(screen.getByRole('button', { name: /My Document/ }));
+        expect(onActivate).toHaveBeenCalledOnce();
+        expect(screen.queryByRole('link')).toBeNull();
+    });
+});
+
+describe('ResourceChangeSummary', () => {
+    it('renders nothing when there are no resources', () => {
+        const { container } = renderWithProviders(<ResourceChangeSummary resources={[]} />);
+        expect(container.querySelector('[data-agent-resource-summary]')).toBeNull();
+    });
+
+    it('renders a header and a chip per resource', () => {
+        const { container } = renderWithProviders(
+            <ResourceChangeSummary
+                resources={[ref({ id: 'd1', label: 'Doc One' }), ref({ type: 'collection', id: 'c1', label: 'Col' })]}
+            />,
+        );
+        expect(container.querySelector('[data-agent-resource-summary]')?.className).not.toContain('bg-muted');
+        expect(screen.getByText('Resources changed')).not.toBeNull();
+        expect(screen.getByText('Doc One')).not.toBeNull();
+        expect(screen.getByText('Col')).not.toBeNull();
+    });
+
+    it('collapses beyond five resources and expands on click', () => {
+        const many = Array.from({ length: 7 }, (_, i) => ref({ id: `d${i}`, label: `Doc ${i}` }));
+        renderWithProviders(<ResourceChangeSummary resources={many} />);
+        // Only 5 shown initially
+        expect(screen.queryByText('Doc 5')).toBeNull();
+        const toggle = screen.getByRole('button', { name: /View all 7 changes/ });
+        fireEvent.click(toggle);
+        expect(screen.getByText('Doc 5')).not.toBeNull();
+        expect(screen.getByText('Doc 6')).not.toBeNull();
+    });
+});

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

@@ -1,9 +1,16 @@
 import { type AgentMessage, AgentMessageType } from '@vertesia/common';
 import { describe, expect, it } from 'vitest';
 import {
+    clearRequestInputIdAnsweredForSession,
+    getAnsweredRequestInputKeys,
     getAnsweredToolApprovalRequestInputKeys,
+    getPendingRequestInputMessage,
     getRequestInputMessageKey,
+    getRequestInputResponseIdFromMetadata,
+    getRequestInputResponseMetadata,
     getToolApprovalResponseMetadata,
+    isRequestInputAnsweredForSession,
+    markRequestInputIdAnsweredForSession,
 } from './requestInputMessages';
 
 const APPROVAL_KEY = 'create_interaction:name:JDE AR Payment Processing Agent';
@@ -78,3 +85,91 @@ describe('getAnsweredToolApprovalRequestInputKeys', () => {
         expect(answered.size).toBe(0);
     });
 });
+
+describe('request input correlation', () => {
+    it('does not apply session acknowledgement to non-request-input messages with the same id', () => {
+        const agentRunId = 'agent-run-1';
+        const requestId = 'request-1';
+        const request = {
+            ...makeApprovalRequest(),
+            details: { request_id: requestId, ux: { options: [{ id: 'allow_once' }] } },
+        };
+        const unrelatedMessage = {
+            ...makeUserAnswer('Still working'),
+            details: { request_id: requestId },
+        };
+
+        markRequestInputIdAnsweredForSession(agentRunId, requestId);
+
+        expect(isRequestInputAnsweredForSession(agentRunId, request)).toBe(true);
+        expect(isRequestInputAnsweredForSession(agentRunId, unrelatedMessage)).toBe(false);
+
+        clearRequestInputIdAnsweredForSession(agentRunId, requestId);
+    });
+
+    it('correlates a persisted response to the matching request id', () => {
+        const firstRequest = {
+            ...makeApprovalRequest(),
+            details: { request_id: 'request-1', ux: { options: [{ id: 'red', label: 'Red' }] } },
+        };
+        const secondRequest = {
+            ...makeApprovalRequest(),
+            timestamp: 2,
+            details: { request_id: 'request-2', ux: { options: [{ id: 'blue', label: 'Blue' }] } },
+        };
+        const answer = {
+            ...makeUserAnswer('red'),
+            timestamp: 3,
+            details: { request_input_response: { request_id: 'request-1' } },
+        };
+
+        const answered = getAnsweredRequestInputKeys([firstRequest, secondRequest, answer]);
+
+        expect(answered.has(getRequestInputMessageKey(firstRequest))).toBe(true);
+        expect(answered.has(getRequestInputMessageKey(secondRequest))).toBe(false);
+        expect(getPendingRequestInputMessage([firstRequest, secondRequest, answer])).toBe(secondRequest);
+    });
+
+    it('adds the request id without discarding existing response metadata', () => {
+        const request = {
+            ...makeApprovalRequest(),
+            details: { request_id: 'request-1', ux: { options: [{ id: 'red', label: 'Red' }] } },
+        };
+
+        expect(getRequestInputResponseMetadata(request, { source: 'free-response' })).toEqual({
+            source: 'free-response',
+            request_input_response: { request_id: 'request-1' },
+        });
+    });
+
+    it('does not let an earlier response resolve a later prompt that reused its request id', () => {
+        const firstRequest = {
+            ...makeApprovalRequest(),
+            details: { request_id: 'reused-request', ux: { options: [{ id: 'allow_once' }] } },
+        };
+        const firstAnswer = {
+            ...makeUserAnswer('allow_once'),
+            details: { request_input_response: { request_id: 'reused-request' } },
+        };
+        const secondRequest = {
+            ...makeApprovalRequest(),
+            timestamp: 3,
+            details: { request_id: 'reused-request', ux: { options: [{ id: 'allow_once' }] } },
+        };
+
+        const answered = getAnsweredRequestInputKeys([firstRequest, firstAnswer, secondRequest]);
+
+        expect(answered.has(getRequestInputMessageKey(firstRequest))).toBe(true);
+        expect(answered.has(getRequestInputMessageKey(secondRequest))).toBe(false);
+        expect(getPendingRequestInputMessage([firstRequest, firstAnswer, secondRequest])).toBe(secondRequest);
+    });
+
+    it('reads a request id from response metadata', () => {
+        expect(
+            getRequestInputResponseIdFromMetadata({
+                request_input_response: { request_id: 'request-1' },
+            }),
+        ).toBe('request-1');
+        expect(getRequestInputResponseIdFromMetadata({ request_input_response: {} })).toBeUndefined();
+    });
+});

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

@@ -96,6 +96,65 @@ export function getRequestInputMessageKey(message: AgentMessage): string {
         .join('|');
 }
 
+export function getRequestInputId(message: AgentMessage): string | undefined {
+    const details = message.details as Record<string, unknown> | undefined;
+    const requestId = details?.request_id ?? details?.tool_use_id;
+    return typeof requestId === 'string' && requestId ? requestId : undefined;
+}
+
+export function getRequestInputResolutionKey(message: AgentMessage): string {
+    return getRequestInputId(message) ?? getRequestInputMessageKey(message);
+}
+
+const ANSWERED_REQUEST_INPUT_STORAGE_PREFIX = 'vertesia:answered-request-input:';
+
+function getAnsweredRequestInputStorageKey(agentRunId: string, requestId: string): string {
+    return `${ANSWERED_REQUEST_INPUT_STORAGE_PREFIX}${agentRunId}:${requestId}`;
+}
+
+export function markRequestInputIdAnsweredForSession(agentRunId: string, requestId: string): void {
+    if (typeof window === 'undefined') return;
+
+    try {
+        window.sessionStorage.setItem(getAnsweredRequestInputStorageKey(agentRunId, requestId), '1');
+    } catch {
+        // Session storage can be unavailable in privacy-restricted browser contexts.
+    }
+}
+
+export function clearRequestInputIdAnsweredForSession(agentRunId: string, requestId: string): void {
+    if (typeof window === 'undefined') return;
+
+    try {
+        window.sessionStorage.removeItem(getAnsweredRequestInputStorageKey(agentRunId, requestId));
+    } catch {
+        // Session storage can be unavailable in privacy-restricted browser contexts.
+    }
+}
+
+export function isRequestInputAnsweredForSession(agentRunId: string, message: AgentMessage): boolean {
+    if (message.type !== AgentMessageType.REQUEST_INPUT) return false;
+
+    const requestId = getRequestInputId(message);
+    if (!requestId || typeof window === 'undefined') return false;
+
+    try {
+        return window.sessionStorage.getItem(getAnsweredRequestInputStorageKey(agentRunId, requestId)) === '1';
+    } catch {
+        return false;
+    }
+}
+
+function getRequestInputResponseId(message: AgentMessage): string | undefined {
+    if (message.type !== AgentMessageType.QUESTION) return undefined;
+
+    const details = getRecord(message.details);
+    const metadata = getRecord(details?.metadata);
+    const response = getRecord(details?.request_input_response) ?? getRecord(metadata?.request_input_response);
+    const requestId = response?.request_id;
+    return typeof requestId === 'string' && requestId ? requestId : undefined;
+}
+
 export function getRequestInputAnswerMessageKey(message: AgentMessage): string {
     const details = message.details as Record<string, unknown> | undefined;
     const keyParts = [
@@ -114,10 +173,22 @@ export function getRequestInputAnswerMessageKey(message: AgentMessage): string {
 
 export function getAnsweredRequestInputKeys(messages: AgentMessage[]): Set<string> {
     const answered = new Set<string>();
+    const latestResponseIndexByRequestId = new Map<string, number>();
+    messages.forEach((message, index) => {
+        const requestId = getRequestInputResponseId(message);
+        if (requestId) latestResponseIndexByRequestId.set(requestId, index);
+    });
 
     messages.forEach((message, index) => {
         if (message.type !== AgentMessageType.REQUEST_INPUT) return;
 
+        const requestId = getRequestInputId(message);
+        const correlatedResponseIndex = requestId ? latestResponseIndexByRequestId.get(requestId) : undefined;
+        if (correlatedResponseIndex !== undefined && correlatedResponseIndex > index) {
+            answered.add(getRequestInputMessageKey(message));
+            return;
+        }
+
         const workstreamId = getWorkstreamId(message);
         for (let nextIndex = index + 1; nextIndex < messages.length; nextIndex += 1) {
             const nextMessage = messages[nextIndex];
@@ -125,7 +196,9 @@ export function getAnsweredRequestInputKeys(messages: AgentMessage[]): Set<strin
 
             if (nextMessage.type === AgentMessageType.REQUEST_INPUT) break;
             if (nextMessage.type === AgentMessageType.QUESTION) {
-                answered.add(getRequestInputMessageKey(message));
+                if (!getRequestInputResponseId(nextMessage)) {
+                    answered.add(getRequestInputMessageKey(message));
+                }
                 break;
             }
         }
@@ -134,6 +207,41 @@ export function getAnsweredRequestInputKeys(messages: AgentMessage[]): Set<strin
     return answered;
 }
 
+export function getRequestInputResponseMetadata(
+    message: AgentMessage,
+    metadata?: Record<string, unknown>,
+): Record<string, unknown> | undefined {
+    const requestId = getRequestInputId(message);
+    if (!requestId) return metadata;
+
+    return {
+        ...metadata,
+        request_input_response: { request_id: requestId },
+    };
+}
+
+export function sendRequestInputResponse(
+    onSendMessage: ((message: string, metadata?: Record<string, unknown>) => void) | undefined,
+    requestMessage: AgentMessage,
+    response: string,
+    metadata?: Record<string, unknown>,
+): void {
+    if (!onSendMessage) return;
+
+    const responseMetadata = getRequestInputResponseMetadata(requestMessage, metadata);
+    if (responseMetadata) {
+        onSendMessage(response, responseMetadata);
+    } else {
+        onSendMessage(response);
+    }
+}
+
+export function getRequestInputResponseIdFromMetadata(metadata?: Record<string, unknown>): string | undefined {
+    const response = getRecord(metadata?.request_input_response);
+    const requestId = response?.request_id;
+    return typeof requestId === 'string' && requestId ? requestId : undefined;
+}
+
 export function getResolvedToolApprovalKeys(messages: AgentMessage[]): Set<string> {
     const resolved = new Set<string>();
 
@@ -300,6 +408,7 @@ export function isRequestInputAnswered(message: AgentMessage, answeredRequestInp
 export function getPendingRequestInputMessage(
     messages: AgentMessage[],
     workstreamId = 'main',
+    locallyAnsweredRequestInputKeys?: ReadonlySet<string>,
 ): RequestInputMessageWithUx | undefined {
     const answeredRequestInputKeys = getAnsweredRequestInputKeys(messages);
     const resolvedToolApprovalKeys = getResolvedToolApprovalKeys(messages);
@@ -308,6 +417,7 @@ export function getPendingRequestInputMessage(
         const message = messages[index];
         if (!hasRequestInputUx(message)) continue;
         if (getWorkstreamId(message) !== workstreamId) continue;
+        if (locallyAnsweredRequestInputKeys?.has(getRequestInputResolutionKey(message))) continue;
         if (isRequestInputAnswered(message, answeredRequestInputKeys)) continue;
         if (isRequestInputResolvedByToolApprovalEvent(message, resolvedToolApprovalKeys)) continue;
         return message;

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