@promptbook/cli 0.114.0-2 → 0.114.0-21

package/apps/agents-server/src/app/admin/planned-messages/usePlannedMessageManagerState.ts

@@ -0,0 +1,289 @@
+'use client';
+
+import {
+    collectPlannedMessageAgentOptions,
+    type PlannedMessageAgentOption,
+} from '@/src/utils/plannedMessageManager/collectPlannedMessageAgentOptions';
+import {
+    createPlannedMessageManagerCounters,
+    type PlannedMessageManagerCounters,
+} from '@/src/utils/plannedMessageManager/createPlannedMessageManagerCounters';
+import {
+    filterPlannedMessages,
+    type PlannedMessageManagerFilters,
+} from '@/src/utils/plannedMessageManager/filterPlannedMessages';
+import {
+    $cancelAdminPlannedMessage,
+    $updateAdminPlannedMessage,
+    type PlannedMessageManagerLastRunFilter,
+    type PlannedMessageManagerRecord,
+    type PlannedMessageManagerRecurrenceFilter,
+    type PlannedMessageManagerSortField,
+    type PlannedMessageManagerView,
+} from '@/src/utils/plannedMessagesAdmin';
+import { useCallback, useDeferredValue, useEffect, useMemo, useState } from 'react';
+import { useAdminTableSorting } from '../_components/adminTableSorting';
+import { createPlannedMessageUpdatePayload, type PlannedMessageEditForm } from './plannedMessageEditForm';
+import { confirmCancelPlannedMessage, showPlannedMessageActionFailure } from './plannedMessageManagerDialogs';
+import {
+    resolvePlannedMessageManagerDefaultSortOrder,
+    resolvePlannedMessageSortValue,
+} from './resolvePlannedMessageSortValue';
+import { usePlannedMessageManagerData, type PlannedMessageManagerData } from './usePlannedMessageManagerData';
+
+/**
+ * Filter value meaning "every agent".
+ *
+ * @private function of PlannedMessageManagerClient
+ */
+export const ANY_PLANNED_MESSAGE_FILTER_VALUE = 'all';
+
+/**
+ * Row action an administrator can start on one planned message.
+ *
+ * @private function of PlannedMessageManagerClient
+ */
+export type PlannedMessageActionKind = 'cancel' | 'pause' | 'edit';
+
+/**
+ * State driving the whole planned-message manager.
+ *
+ * @private function of PlannedMessageManagerClient
+ */
+export type UsePlannedMessageManagerStateResult = {
+    readonly data: PlannedMessageManagerData;
+    readonly counters: PlannedMessageManagerCounters;
+    readonly agentOptions: Array<PlannedMessageAgentOption>;
+    readonly filters: PlannedMessageManagerFilters;
+    readonly searchInput: string;
+    readonly visiblePlannedMessages: Array<PlannedMessageManagerRecord>;
+    readonly matchedCount: number;
+
+    readonly page: number;
+    readonly pageSize: number;
+    readonly totalPages: number;
+    readonly isPreviousPageDisabled: boolean;
+    readonly isNextPageDisabled: boolean;
+    readonly goToPreviousPage: () => void;
+    readonly goToNextPage: () => void;
+    readonly updatePageSize: (value: string) => void;
+
+    readonly sortBy: PlannedMessageManagerSortField;
+    readonly sortOrder: 'asc' | 'desc';
+    readonly handleSortChange: (sortBy: PlannedMessageManagerSortField) => void;
+
+    readonly selectView: (view: PlannedMessageManagerView) => void;
+    readonly updateAgentPermanentId: (agentPermanentId: string) => void;
+    readonly updateRecurrence: (recurrence: string) => void;
+    readonly updateLastRun: (lastRun: string) => void;
+    readonly updateSearchInput: (search: string) => void;
+
+    readonly busyTimeoutId: string | null;
+    readonly busyAction: PlannedMessageActionKind | null;
+    readonly cancelPlannedMessage: (plannedMessage: PlannedMessageManagerRecord) => Promise<void>;
+    readonly togglePlannedMessagePaused: (plannedMessage: PlannedMessageManagerRecord) => Promise<void>;
+
+    readonly editedPlannedMessage: PlannedMessageManagerRecord | null;
+    readonly openPlannedMessageEditor: (plannedMessage: PlannedMessageManagerRecord) => void;
+    readonly closePlannedMessageEditor: () => void;
+    readonly submitPlannedMessageEdit: (form: PlannedMessageEditForm) => Promise<boolean>;
+};
+
+/**
+ * Manages the filters, the ordering, the paging, and the actions of the planned-message manager.
+ *
+ * @returns Everything the planned-message manager renders and does.
+ *
+ * @private function of PlannedMessageManagerClient
+ */
+export function usePlannedMessageManagerState(): UsePlannedMessageManagerStateResult {
+    const data = usePlannedMessageManagerData();
+    const [view, setView] = useState<PlannedMessageManagerView>('active');
+    const [agentPermanentId, setAgentPermanentId] = useState<string>(ANY_PLANNED_MESSAGE_FILTER_VALUE);
+    const [recurrence, setRecurrence] = useState<PlannedMessageManagerRecurrenceFilter>(
+        ANY_PLANNED_MESSAGE_FILTER_VALUE,
+    );
+    const [lastRun, setLastRun] = useState<PlannedMessageManagerLastRunFilter>(ANY_PLANNED_MESSAGE_FILTER_VALUE);
+    const [searchInput, setSearchInput] = useState('');
+    const search = useDeferredValue(searchInput);
+    const [page, setPage] = useState(1);
+    const [pageSize, setPageSize] = useState(25);
+    const [busyTimeoutId, setBusyTimeoutId] = useState<string | null>(null);
+    const [busyAction, setBusyAction] = useState<PlannedMessageActionKind | null>(null);
+    const [editedPlannedMessage, setEditedPlannedMessage] = useState<PlannedMessageManagerRecord | null>(null);
+
+    const { plannedMessages, generatedAt, refreshNow } = data;
+
+    const filters = useMemo<PlannedMessageManagerFilters>(
+        () => ({ view, agentPermanentId, recurrence, lastRun, search: search.trim() }),
+        [agentPermanentId, lastRun, recurrence, search, view],
+    );
+
+    // Note: The stages were resolved when the listing was read, so the same moment decides the windows
+    const filteredAtDate = useMemo(() => (generatedAt ? new Date(generatedAt) : new Date()), [generatedAt]);
+
+    const counters = useMemo(() => createPlannedMessageManagerCounters(plannedMessages), [plannedMessages]);
+    const agentOptions = useMemo(() => collectPlannedMessageAgentOptions(plannedMessages), [plannedMessages]);
+    const filteredPlannedMessages = useMemo(
+        () => filterPlannedMessages(plannedMessages, filters, filteredAtDate),
+        [filteredAtDate, filters, plannedMessages],
+    );
+
+    const { handleSortChange, sortBy, sortedRows, sortOrder } = useAdminTableSorting<
+        PlannedMessageManagerRecord,
+        PlannedMessageManagerSortField
+    >({
+        defaultSortBy: 'nextRun',
+        resolveDefaultSortOrder: resolvePlannedMessageManagerDefaultSortOrder,
+        resolveSortValue: resolvePlannedMessageSortValue,
+        rows: filteredPlannedMessages,
+    });
+
+    const totalPages = Math.max(1, Math.ceil(sortedRows.length / pageSize));
+
+    useEffect(() => {
+        setPage(1);
+    }, [filters, pageSize]);
+
+    useEffect(() => {
+        if (page > totalPages) {
+            setPage(totalPages);
+        }
+    }, [page, totalPages]);
+
+    const visiblePlannedMessages = useMemo(
+        () => sortedRows.slice((page - 1) * pageSize, page * pageSize),
+        [page, pageSize, sortedRows],
+    );
+
+    const runPlannedMessageAction = useCallback(
+        async (options: {
+            plannedMessage: PlannedMessageManagerRecord;
+            action: PlannedMessageActionKind;
+            failureTitle: string;
+            execute: () => Promise<void>;
+        }): Promise<boolean> => {
+            try {
+                setBusyTimeoutId(options.plannedMessage.timeoutId);
+                setBusyAction(options.action);
+                await options.execute();
+                refreshNow();
+                return true;
+            } catch (actionError) {
+                await showPlannedMessageActionFailure(options.failureTitle, actionError);
+                return false;
+            } finally {
+                setBusyTimeoutId(null);
+                setBusyAction(null);
+            }
+        },
+        [refreshNow],
+    );
+
+    const cancelPlannedMessage = useCallback(
+        async (plannedMessage: PlannedMessageManagerRecord): Promise<void> => {
+            if (!(await confirmCancelPlannedMessage(plannedMessage))) {
+                return;
+            }
+
+            await runPlannedMessageAction({
+                plannedMessage,
+                action: 'cancel',
+                failureTitle: 'Cancellation failed',
+                execute: () => $cancelAdminPlannedMessage(plannedMessage.timeoutId),
+            });
+        },
+        [runPlannedMessageAction],
+    );
+
+    const togglePlannedMessagePaused = useCallback(
+        async (plannedMessage: PlannedMessageManagerRecord): Promise<void> => {
+            await runPlannedMessageAction({
+                plannedMessage,
+                action: 'pause',
+                failureTitle: plannedMessage.pausedAt ? 'Resuming failed' : 'Pausing failed',
+                execute: async () => {
+                    await $updateAdminPlannedMessage(plannedMessage.timeoutId, {
+                        isPaused: plannedMessage.pausedAt === null,
+                    });
+                },
+            });
+        },
+        [runPlannedMessageAction],
+    );
+
+    const submitPlannedMessageEdit = useCallback(
+        async (form: PlannedMessageEditForm): Promise<boolean> => {
+            if (editedPlannedMessage === null) {
+                return false;
+            }
+
+            const isApplied = await runPlannedMessageAction({
+                plannedMessage: editedPlannedMessage,
+                action: 'edit',
+                failureTitle: 'Change failed',
+                execute: async () => {
+                    await $updateAdminPlannedMessage(
+                        editedPlannedMessage.timeoutId,
+                        createPlannedMessageUpdatePayload(form),
+                    );
+                },
+            });
+
+            if (isApplied) {
+                setEditedPlannedMessage(null);
+            }
+
+            return isApplied;
+        },
+        [editedPlannedMessage, runPlannedMessageAction],
+    );
+
+    return {
+        data,
+        counters,
+        agentOptions,
+        filters,
+        searchInput,
+        visiblePlannedMessages,
+        matchedCount: sortedRows.length,
+
+        page,
+        pageSize,
+        totalPages,
+        isPreviousPageDisabled: page <= 1,
+        isNextPageDisabled: page >= totalPages,
+        goToPreviousPage: useCallback(() => setPage((currentPage) => Math.max(1, currentPage - 1)), []),
+        goToNextPage: useCallback(
+            () => setPage((currentPage) => Math.min(totalPages, currentPage + 1)),
+            [totalPages],
+        ),
+        updatePageSize: useCallback((value: string) => setPageSize(Number.parseInt(value, 10) || 25), []),
+
+        sortBy,
+        sortOrder,
+        handleSortChange,
+
+        selectView: useCallback((nextView: PlannedMessageManagerView) => setView(nextView), []),
+        updateAgentPermanentId: useCallback((value: string) => setAgentPermanentId(value), []),
+        updateRecurrence: useCallback(
+            (value: string) => setRecurrence(value as PlannedMessageManagerRecurrenceFilter),
+            [],
+        ),
+        updateLastRun: useCallback((value: string) => setLastRun(value as PlannedMessageManagerLastRunFilter), []),
+        updateSearchInput: useCallback((value: string) => setSearchInput(value), []),
+
+        busyTimeoutId,
+        busyAction,
+        cancelPlannedMessage,
+        togglePlannedMessagePaused,
+
+        editedPlannedMessage,
+        openPlannedMessageEditor: useCallback(
+            (plannedMessage: PlannedMessageManagerRecord) => setEditedPlannedMessage(plannedMessage),
+            [],
+        ),
+        closePlannedMessageEditor: useCallback(() => setEditedPlannedMessage(null), []),
+        submitPlannedMessageEdit,
+    };
+}

package/apps/agents-server/src/app/admin/task-manager/TaskManagerClient.tsx

@@ -4,7 +4,12 @@ import { $fetchVpsAdminChatTasks } from '@/src/utils/chatTasksAdmin';
 import { Card } from '../../../components/Homepage/Card';
 import { useServerLanguage } from '../../../components/ServerLanguage/ServerLanguageProvider';
 import { TaskManagerFiltersCard } from './TaskManagerFiltersCard';
-import { SERVER_TASK_MANAGER_PATH, TaskManagerScopeTabs, VPS_TASK_MANAGER_PATH, type TaskManagerScope } from './TaskManagerScopeTabs';
+import {
+    AdminTaskManagerTabs,
+    SERVER_TASK_MANAGER_PATH,
+    VPS_TASK_MANAGER_PATH,
+    type TaskManagerScope,
+} from '../_components/AdminTaskManagerTabs';
 import { TaskManagerSummaryMetrics } from './TaskManagerSummaryMetrics';
 import { TaskManagerTasksCard } from './TaskManagerTasksCard';
 import { useTaskManagerState } from './useTaskManagerState';
@@ -42,7 +47,7 @@ export function TaskManagerClient({ isSuperAdmin, scope = 'server' }: TaskManage
     return (
         <div className="container mx-auto space-y-6 px-4 py-8">
             <div className="mt-20">
-                <TaskManagerScopeTabs activeScope={scope} isSuperAdmin={isSuperAdmin} />
+                <AdminTaskManagerTabs activeTabId={scope} isSuperAdmin={isSuperAdmin} />
             </div>
 
             <div className="flex flex-col gap-4 md:flex-row md:items-end md:justify-between">

package/apps/agents-server/src/app/admin/task-manager/TaskManagerFiltersCard.tsx

@@ -1,6 +1,6 @@
 import type { AdminChatTaskView } from '@/src/utils/chatTasksAdmin';
-import type { ReactNode } from 'react';
 import { Card } from '../../../components/Homepage/Card';
+import { AdminFilterField, AdminFilterSelectField } from '../_components/AdminFilterFields';
 import type { useTaskManagerState } from './useTaskManagerState';
 
 /**
@@ -23,31 +23,6 @@ type TaskManagerFiltersCardProps = {
     state: ReturnType<typeof useTaskManagerState>;
 };
 
-/**
- * Props for the shared field wrapper.
- *
- * @private function of TaskManagerFiltersCard
- */
-type FieldProps = {
-    children: ReactNode;
-    htmlFor: string;
-    label: string;
-};
-
-/**
- * Props for the shared select field.
- *
- * @private function of TaskManagerFiltersCard
- */
-type SelectFieldProps = {
-    disabled?: boolean;
-    id: string;
-    label: string;
-    onChange: (value: string) => void;
-    options: Array<{ label: string; value: string }>;
-    value: string;
-};
-
 /**
  * Available dashboard tabs.
  *
@@ -108,47 +83,6 @@ const TASK_TIME_WINDOW_OPTIONS = [
     { value: '168', label: '7 days' },
 ];
 
-/**
- * Shared field wrapper for compact filter controls.
- *
- * @private function of TaskManagerFiltersCard
- */
-function Field({ children, htmlFor, label }: FieldProps) {
-    return (
-        <div className="flex flex-col gap-1">
-            <label htmlFor={htmlFor} className="text-sm font-medium text-gray-700">
-                {label}
-            </label>
-            {children}
-        </div>
-    );
-}
-
-/**
- * Shared select field used in the filter panel.
- *
- * @private function of TaskManagerFiltersCard
- */
-function SelectField({ disabled, id, label, onChange, options, value }: SelectFieldProps) {
-    return (
-        <Field label={label} htmlFor={id}>
-            <select
-                id={id}
-                value={value}
-                disabled={disabled}
-                onChange={(event) => onChange(event.target.value)}
-                className="rounded-md border border-gray-300 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-500 disabled:cursor-not-allowed disabled:bg-gray-100 disabled:text-gray-400"
-            >
-                {options.map((option) => (
-                    <option key={option.value} value={option.value}>
-                        {option.label}
-                    </option>
-                ))}
-            </select>
-        </Field>
-    );
-}
-
 /**
  * Resolves the current explanatory text for the selected task view.
  *
@@ -196,7 +130,7 @@ export function TaskManagerFiltersCard({ state }: TaskManagerFiltersCardProps) {
                 </div>
 
                 <div className="grid gap-4 lg:grid-cols-[minmax(0,2fr)_repeat(4,minmax(0,1fr))]">
-                    <Field label="Search" htmlFor="task-search">
+                    <AdminFilterField label="Search" htmlFor="task-search">
                         <input
                             id="task-search"
                             type="text"
@@ -205,9 +139,9 @@ export function TaskManagerFiltersCard({ state }: TaskManagerFiltersCardProps) {
                             placeholder="Task id / chat id / user id / agent id"
                             className="w-full rounded-md border border-gray-300 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
                         />
-                    </Field>
+                    </AdminFilterField>
 
-                    <SelectField
+                    <AdminFilterSelectField
                         id="task-page-size"
                         label="Page size"
                         value={String(state.pageSize)}
@@ -215,7 +149,7 @@ export function TaskManagerFiltersCard({ state }: TaskManagerFiltersCardProps) {
                         options={TASK_PAGE_SIZE_OPTIONS}
                     />
 
-                    <SelectField
+                    <AdminFilterSelectField
                         id="task-poll-interval"
                         label="Auto-refresh"
                         value={String(state.pollIntervalMs)}
@@ -223,7 +157,7 @@ export function TaskManagerFiltersCard({ state }: TaskManagerFiltersCardProps) {
                         options={TASK_POLL_INTERVAL_OPTIONS}
                     />
 
-                    <SelectField
+                    <AdminFilterSelectField
                         id="task-stuck-threshold"
                         label="Stuck after"
                         value={String(state.stuckThresholdMinutes)}
@@ -231,7 +165,7 @@ export function TaskManagerFiltersCard({ state }: TaskManagerFiltersCardProps) {
                         options={TASK_STUCK_THRESHOLD_OPTIONS}
                     />
 
-                    <SelectField
+                    <AdminFilterSelectField
                         id="task-time-window"
                         label="All window"
                         value={String(state.timeWindowHours)}

package/apps/agents-server/src/app/admin/task-manager/TaskManagerSummaryMetrics.tsx

@@ -1,3 +1,4 @@
+import { AdminMetricCard } from '../_components/AdminMetricCard';
 import type { useTaskManagerState } from './useTaskManagerState';
 
 /**
@@ -7,32 +8,6 @@ import type { useTaskManagerState } from './useTaskManagerState';
  */
 type TaskManagerSummaryMetricsProps = Pick<ReturnType<typeof useTaskManagerState>, 'counters' | 'oldestQueuedAgeLabel'>;
 
-/**
- * Props for one summary metric card.
- *
- * @private function of TaskManagerSummaryMetrics
- */
-type MetricCardProps = {
-    caption: string;
-    label: string;
-    value: string;
-};
-
-/**
- * Small metric card used in the task-manager summary header.
- *
- * @private function of TaskManagerSummaryMetrics
- */
-function MetricCard({ caption, label, value }: MetricCardProps) {
-    return (
-        <div className="rounded-2xl border border-gray-200 bg-white p-5 shadow-sm">
-            <div className="text-xs font-semibold uppercase tracking-wide text-gray-400">{label}</div>
-            <div className="mt-2 text-3xl font-light text-gray-900">{value}</div>
-            <div className="mt-1 text-sm text-gray-500">{caption}</div>
-        </div>
-    );
-}
-
 /**
  * Renders the summary counters above the task table.
  *
@@ -41,22 +16,22 @@ function MetricCard({ caption, label, value }: MetricCardProps) {
 export function TaskManagerSummaryMetrics({ counters, oldestQueuedAgeLabel }: TaskManagerSummaryMetricsProps) {
     return (
         <div className="grid gap-4 md:grid-cols-2 xl:grid-cols-4">
-            <MetricCard
+            <AdminMetricCard
                 label="Running"
                 value={counters ? counters.runningCount.toLocaleString() : '...'}
                 caption="Workers in flight"
             />
-            <MetricCard
+            <AdminMetricCard
                 label="Queued"
                 value={counters ? counters.queuedCount.toLocaleString() : '...'}
                 caption="Tasks waiting to start"
             />
-            <MetricCard
+            <AdminMetricCard
                 label="Failed 24h"
                 value={counters ? counters.failedLast24hCount.toLocaleString() : '...'}
                 caption="Recent failures"
             />
-            <MetricCard label="Oldest queued" value={oldestQueuedAgeLabel} caption="Backlog age" />
+            <AdminMetricCard label="Oldest queued" value={oldestQueuedAgeLabel} caption="Backlog age" />
         </div>
     );
 }

package/apps/agents-server/src/app/admin/task-manager/TaskManagerTaskRow.tsx

@@ -13,6 +13,7 @@ import {
     buildTaskRunReportRows,
     formatTaskDateTime,
     formatTaskDuration,
+    AgentGoalTaskBadge,
     formatTaskKind,
     getTaskQueueAgeMs,
     getTaskRuntimeDurationMs,
@@ -175,6 +176,7 @@ export function TaskManagerTaskRow({
                     <span className="rounded-full border border-gray-200 bg-gray-50 px-2 py-0.5 font-medium text-gray-600">
                         {formatTaskKind(task.kind)}
                     </span>
+                    <AgentGoalTaskBadge task={task} />
                 </div>
                 <div className="mt-2 space-y-1 text-[11px] text-gray-500">
                     <div>

package/apps/agents-server/src/app/admin/task-manager/[taskId]/TaskManagerTaskDetailClient.tsx

@@ -16,11 +16,12 @@ import {
 import { TaskManagerTaskLogActions } from '../TaskManagerTaskLogActions';
 import { TaskManagerTaskTargetLink } from '../TaskManagerTaskTargetLink';
 import { TaskManagerTaskTerminalDialog } from '../TaskManagerTaskTerminalDialog';
-import { SERVER_TASK_MANAGER_PATH, VPS_TASK_MANAGER_PATH } from '../TaskManagerScopeTabs';
+import { SERVER_TASK_MANAGER_PATH, VPS_TASK_MANAGER_PATH } from '../../_components/AdminTaskManagerTabs';
 import {
     buildTaskRunReportRows,
     formatTaskDateTime,
     formatTaskDuration,
+    AgentGoalTaskBadge,
     formatTaskKind,
     getTaskQueueAgeMs,
     getTaskRuntimeDurationMs,
@@ -217,6 +218,7 @@ export function TaskManagerTaskDetailClient({ taskId, isSuperAdmin, serverDomain
                             <span className="rounded-full border border-gray-200 bg-gray-50 px-2 py-0.5 text-[11px] font-medium text-gray-600">
                                 {formatTaskKind(task.kind)}
                             </span>
+                            <AgentGoalTaskBadge task={task} />
                             {task.cancelRequestedAt ? (
                                 <span className="text-[11px] font-medium text-orange-700">Cancellation requested</span>
                             ) : null}

package/apps/agents-server/src/app/admin/task-manager/taskManagerTaskPresentation.tsx

@@ -96,6 +96,29 @@ export function TaskStatusBadge({ isStuck, task }: TaskStatusBadgeProps) {
     return <span className={`rounded-full border px-2 py-0.5 text-[11px] font-semibold ${tone}`}>{label}</span>;
 }
 
+/**
+ * Compact badge marking the tasks an agent started for itself in its goal chat.
+ *
+ * Goal-chat tasks keep their normal kind, so this badge is what separates them from the
+ * user-invoked tasks in every task-manager surface.
+ *
+ * @private shared presentation of the admin task manager
+ */
+export function AgentGoalTaskBadge({ task }: { task: AdminChatTaskRecord }) {
+    if (!task.isAgentGoalTask) {
+        return null;
+    }
+
+    return (
+        <span
+            className="rounded-full border border-indigo-200 bg-indigo-50 px-2 py-0.5 text-[11px] font-semibold text-indigo-700"
+            title="Started by the agent itself in its goal chat, not by a user"
+        >
+            Goal chat
+        </span>
+    );
+}
+
 /**
  * Formats a durable task kind for display.
  *

package/apps/agents-server/src/app/agents/[agentName]/AgentChatWrapper.tsx

@@ -6,8 +6,10 @@ import { AgentChat, ChatMessage, useSendMessageToLlmChat } from '@promptbook-loc
 import { RemoteAgent } from '@promptbook-local/core';
 import { ClientVersionMismatchError } from '@promptbook-local/utils';
 import { useCallback, useEffect, useMemo, useState, type CSSProperties } from 'react';
+import { AGENT_PROJECT_TOOL_CALL_NAME } from '../../../../../../src/book-components/Chat/utils/agentProjectToolCall';
 import { string_agent_url } from '../../../../../../src/types/typeAliases';
 import type { AgentProjectItemInfo } from '../../../components/AgentProjects/AgentProjectReferencesList';
+import { useAgentProjectMarkdownReferences } from '../../../components/AgentProjects/useAgentProjectMarkdownReferences';
 import { useAgentBackground } from '../../../components/AgentProfile/useAgentBackground';
 import { useChatEnterBehaviorPreferences } from '../../../components/ChatEnterBehavior/ChatEnterBehaviorPreferencesProvider';
 import { ChatErrorDialog } from '../../../components/ChatErrorDialog';
@@ -33,7 +35,6 @@ import { reportClientVersionMismatch } from '../../../utils/clientVersionClient'
 import type { FriendlyErrorMessage } from '../../../utils/errorMessages';
 import { handleChatError } from '../../../utils/errorMessages';
 import { fetchGithubAppStatus, type GithubAppStatusResponse } from '../../../utils/githubAppClient';
-import { createAgentProjectMarkdownReferences } from '../../../utils/agentProjects/createAgentProjectMarkdownReferences';
 import { createDefaultSpeechRecognition } from '../../../utils/speech-to-text/createDefaultSpeechRecognition';
 import { chatFileUploadHandler } from '../../../utils/upload/createBookEditorUploadHandler';
 import {
@@ -144,14 +145,6 @@ export function AgentChatWrapper(props: AgentChatWrapperProps) {
 
     const { value: agent } = usePromise(agentPromise, [agentPromise]);
     const teamAgentProfiles = useTeamAgentProfiles(agent?.capabilities);
-    const markdownInlineReferences = useMemo(
-        () =>
-            createAgentProjectMarkdownReferences({
-                agentPermanentId: agentName,
-                projects: projectReferences,
-            }),
-        [agentName, projectReferences],
-    );
 
     // Error state management
     const [currentError, setCurrentError] = useState<FriendlyErrorMessage | null>(null);
@@ -161,6 +154,11 @@ export function AgentChatWrapper(props: AgentChatWrapperProps) {
     const [githubAppStatus, setGithubAppStatus] = useState<GithubAppStatusResponse | null>(null);
     const [calendarOAuthStatus, setCalendarOAuthStatus] = useState<CalendarOAuthStatusResponse | null>(null);
     const [renderedMessages, setRenderedMessages] = useState<ReadonlyArray<ChatMessage>>([]);
+    const markdownInlineReferences = useAgentProjectMarkdownReferences({
+        agentPermanentId: agentName,
+        projects: projectReferences,
+        messages: renderedMessages,
+    });
     const currentAgentPermanentId = useMemo(() => {
         return typeof (agent as { permanentId?: unknown } | undefined)?.permanentId === 'string'
             ? ((agent as { permanentId?: string }).permanentId as string)
@@ -458,6 +456,7 @@ export function AgentChatWrapper(props: AgentChatWrapperProps) {
                 project_delete_file: t('chat.toolTitle.projectFileDeleter'),
                 project_create_branch: t('chat.toolTitle.projectBranchCreator'),
                 project_create_pull_request: t('chat.toolTitle.projectPullRequestCreator'),
+                [AGENT_PROJECT_TOOL_CALL_NAME]: t('chat.toolTitle.agentProjectTouched'),
             }}
             feedbackMode={toChatComponentFeedbackMode(feedbackMode)}
             onFeedback={shouldEnableFeedback ? handleFeedback : undefined}

package/apps/agents-server/src/app/agents/[agentName]/AgentProfileChat.tsx

@@ -21,12 +21,12 @@ import { useFileUploadAvailability } from '../../../components/FileUploadAvailab
 import { createMyChatsMobileMenuItem } from '../../../components/Header/createMyChatsMobileMenuItem';
 import { useHoistedMobileMenuItems } from '../../../components/Header/MobileMenuHoistingContext';
 import type { AgentProjectItemInfo } from '../../../components/AgentProjects/AgentProjectReferencesList';
+import { useAgentProjectMarkdownReferences } from '../../../components/AgentProjects/useAgentProjectMarkdownReferences';
 import { usePrivateModePreferences } from '../../../components/PrivateModePreferences/PrivateModePreferencesProvider';
 import { useServerLanguage } from '../../../components/ServerLanguage/ServerLanguageProvider';
 import { ChatThreadLoadingSkeleton } from '../../../components/Skeleton/ChatThreadLoadingSkeleton';
 import { usePromptbookTheme } from '../../../components/ThemeMode/usePromptbookTheme';
 import type { ServerLanguageCode } from '../../../languages/ServerLanguageRegistry';
-import { createAgentProjectMarkdownReferences } from '../../../utils/agentProjects/createAgentProjectMarkdownReferences';
 import { buildFreshAgentChatHref } from '../../../utils/agentRouting/agentRouteHrefs';
 import { executeQuickActionButton } from '../../../utils/chat/executeQuickActionButton';
 import { resolveChatMessageValidationIssue } from '../../../utils/chat/validateChatMessageContent';
@@ -284,14 +284,10 @@ export function AgentProfileChat({
     keepUnused(isCreatingAgent);
 
     const chatRoute = useMemo(() => `/agents/${encodeURIComponent(agentName)}/chat`, [agentName]);
-    const markdownInlineReferences = useMemo(
-        () =>
-            createAgentProjectMarkdownReferences({
-                agentPermanentId: agentName,
-                projects: projectReferences,
-            }),
-        [agentName, projectReferences],
-    );
+    const markdownInlineReferences = useAgentProjectMarkdownReferences({
+        agentPermanentId: agentName,
+        projects: projectReferences,
+    });
     const agentPromise = useMemo(
         () =>
             RemoteAgent.connect({