@promptbook/cli 0.114.0-0 → 0.114.0-10

package/apps/agents-server/src/app/admin/messages/MessagesClient.tsx

@@ -7,13 +7,14 @@ import type { ServerLanguageCode } from '../../../languages/ServerLanguageRegist
 import {
     $fetchMessages,
     type MessageRow,
-    type MessageSendAttemptRow,
     type MessageSortField,
     type MessageSortOrder,
 } from '../../../utils/messagesAdmin';
 import { formatServerLanguageHumanReadableDate } from '../../../utils/localization/formatServerLanguageHumanReadableDate';
 import { AdminSortableTableHeaderCell } from '../_components/AdminSortableTableHeaderCell';
 import { resolveNextAdminTableSortState } from '../_components/adminTableSorting';
+import { MessageParticipants } from './MessageParticipants';
+import { MessageStatus } from './MessageStatus';
 
 /**
  * Formats date.
@@ -30,20 +31,6 @@ function getMessagePreview(content: string, maxLength = 120): string {
     return content.length > maxLength ? `${content.slice(0, maxLength)}…` : content;
 }
 
-/**
- * Gets status badge.
- */
-function getStatusBadge(attempts: MessageSendAttemptRow[] | undefined) {
-    if (!attempts || attempts.length === 0) {
-        return <span className="inline-flex items-center px-2 py-0.5 rounded text-xs font-medium bg-gray-100 text-gray-800">Pending</span>;
-    }
-    const success = attempts.find(a => a.isSuccessful);
-    if (success) {
-        return <span className="inline-flex items-center px-2 py-0.5 rounded text-xs font-medium bg-green-100 text-green-800">Sent ({success.providerName})</span>;
-    }
-    return <span className="inline-flex items-center px-2 py-0.5 rounded text-xs font-medium bg-red-100 text-red-800">Failed ({attempts.length})</span>;
-}
-
 /**
  * Resolves the initial direction used when switching message sort fields.
  */
@@ -227,7 +214,10 @@ export function MessagesClient() {
                             <select
                                 id="channelFilter"
                                 value={channel}
-                                onChange={(e) => { setChannel(e.target.value); setPage(1); }}
+                                onChange={(e) => {
+                                    setChannel(e.target.value);
+                                    setPage(1);
+                                }}
                                 className="w-full md:w-40 px-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
                             >
                                 <option value="">All</option>
@@ -243,7 +233,10 @@ export function MessagesClient() {
                             <select
                                 id="directionFilter"
                                 value={direction}
-                                onChange={(e) => { setDirection(e.target.value); setPage(1); }}
+                                onChange={(e) => {
+                                    setDirection(e.target.value);
+                                    setPage(1);
+                                }}
                                 className="w-full md:w-40 px-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
                             >
                                 <option value="">All</option>
@@ -337,26 +330,22 @@ export function MessagesClient() {
                                         <td className="whitespace-nowrap px-4 py-3 text-gray-700">
                                             {formatDate(row.createdAt, language)}
                                         </td>
-                                        <td className="whitespace-nowrap px-4 py-3 text-gray-700">
-                                            {row.channel}
-                                        </td>
-                                        <td className="whitespace-nowrap px-4 py-3 text-gray-700">
-                                            {row.direction}
+                                        <td className="whitespace-nowrap px-4 py-3 text-gray-700">{row.channel}</td>
+                                        <td className="whitespace-nowrap px-4 py-3 text-gray-700">{row.direction}</td>
+                                        <td className="max-w-sm px-4 py-3 align-top text-gray-700">
+                                            <MessageParticipants
+                                                channel={row.channel}
+                                                sender={row.sender}
+                                                recipients={row.recipients}
+                                            />
                                         </td>
-                                        <td className="max-w-xs px-4 py-3 text-gray-700">
-                                            <div className="truncate" title={JSON.stringify({ sender: row.sender, recipients: row.recipients }, null, 2)}>
-                                                {/* Simple preview of sender/recipients */}
-                                                S: {JSON.stringify(row.sender)}<br/>
-                                                R: {JSON.stringify(row.recipients)}
-                                            </div>
-                                        </td>
-                                        <td className="max-w-md px-4 py-3 text-gray-700">
+                                        <td className="max-w-md px-4 py-3 align-top text-gray-700">
                                             <div className="max-h-24 overflow-hidden overflow-ellipsis text-xs leading-snug">
                                                 {getMessagePreview(row.content)}
                                             </div>
                                         </td>
-                                        <td className="whitespace-nowrap px-4 py-3 text-gray-700">
-                                            {getStatusBadge(row.sendAttempts)}
+                                        <td className="px-4 py-3 align-top text-gray-700">
+                                            <MessageStatus direction={row.direction} attempts={row.sendAttempts} />
                                         </td>
                                     </tr>
                                 ))}

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

@@ -0,0 +1,289 @@
+import type { string_email } from '@promptbook-local/types';
+import type { Json } from '../../../database/schema';
+import { parseEmailAddress } from '../../../message-providers/email/_common/utils/parseEmailAddress';
+import type { MessageSendAttemptRow } from '../../../utils/messagesAdmin';
+
+/**
+ * Contact normalized for display in the messages administration table.
+ */
+export type MessageContact = {
+    readonly fullName: string | null;
+    readonly address: string;
+    readonly isEmail: boolean;
+};
+
+/**
+ * Status variants rendered by the messages administration table.
+ */
+export type MessageStatusKind = 'received' | 'pending' | 'sent' | 'failed';
+
+/**
+ * Direction-aware message status prepared for rendering.
+ */
+export type MessageStatusPresentation = {
+    readonly kind: MessageStatusKind;
+    readonly attemptCount: number;
+    readonly providerName: string | null;
+};
+
+/**
+ * Error fields extracted from a persisted provider response.
+ */
+type MessageSendAttemptError = {
+    readonly name: string | null;
+    readonly message: string;
+    readonly stack: string | null;
+};
+
+/**
+ * Converts arbitrary sender or recipient JSON into consistently renderable contacts.
+ */
+export function normalizeMessageContacts(value: Json): MessageContact[] {
+    if (value === null || value === undefined) {
+        return [];
+    }
+
+    if (Array.isArray(value)) {
+        return value.flatMap(normalizeMessageContacts);
+    }
+
+    if (typeof value === 'string') {
+        return [createMessageContact(value)];
+    }
+
+    if (typeof value === 'object') {
+        const address = readFirstStringProperty(value, ['fullEmail', 'email', 'address']);
+        const fullName = readFirstStringProperty(value, ['fullName', 'name']);
+
+        if (address) {
+            return [createMessageContact(address, fullName)];
+        }
+
+        return [createMessageContact(JSON.stringify(value) || String(value))];
+    }
+
+    return [createMessageContact(String(value))];
+}
+
+/**
+ * Resolves message status without treating received inbound messages as unsent outbound messages.
+ */
+export function resolveMessageStatusPresentation(
+    direction: string,
+    attempts: ReadonlyArray<MessageSendAttemptRow> | undefined,
+): MessageStatusPresentation {
+    const normalizedAttempts = attempts || [];
+
+    if (direction === 'INBOUND') {
+        return {
+            kind: 'received',
+            attemptCount: normalizedAttempts.length,
+            providerName: null,
+        };
+    }
+
+    const successfulAttempt = normalizedAttempts.find((attempt) => attempt.isSuccessful);
+    if (successfulAttempt) {
+        return {
+            kind: 'sent',
+            attemptCount: normalizedAttempts.length,
+            providerName: successfulAttempt.providerName,
+        };
+    }
+
+    if (normalizedAttempts.length > 0) {
+        return {
+            kind: 'failed',
+            attemptCount: normalizedAttempts.length,
+            providerName: null,
+        };
+    }
+
+    return {
+        kind: 'pending',
+        attemptCount: 0,
+        providerName: null,
+    };
+}
+
+/**
+ * Returns failed send attempts in chronological order for stable diagnostic output.
+ */
+export function getFailedMessageSendAttempts(
+    attempts: ReadonlyArray<MessageSendAttemptRow> | undefined,
+): MessageSendAttemptRow[] {
+    return [...(attempts || [])]
+        .filter((attempt) => !attempt.isSuccessful)
+        .sort(compareMessageSendAttemptsChronologically);
+}
+
+/**
+ * Extracts the most recent useful provider error message for the compact table view.
+ */
+export function resolveLatestMessageSendAttemptErrorMessage(
+    attempts: ReadonlyArray<MessageSendAttemptRow> | undefined,
+): string | null {
+    const failedAttempts = getFailedMessageSendAttempts(attempts);
+
+    for (let index = failedAttempts.length - 1; index >= 0; index -= 1) {
+        const error = resolveMessageSendAttemptError(failedAttempts[index]!.raw);
+        if (error) {
+            return error.message;
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Formats one complete persisted delivery attempt, including the readable stack and untouched raw response.
+ */
+export function formatMessageSendAttemptLog(attempt: MessageSendAttemptRow): string {
+    const normalizedRaw = parseStoredJsonValue(attempt.raw);
+    const error = resolveMessageSendAttemptError(normalizedRaw);
+    const errorLines = error
+        ? [
+              '',
+              'Error:',
+              ...(error.name ? [`Name: ${error.name}`] : []),
+              `Message: ${error.message}`,
+              ...(error.stack ? ['Stack:', error.stack] : []),
+          ]
+        : [];
+
+    return [
+        `Attempt ID: ${attempt.id}`,
+        `Time: ${attempt.createdAt || '-'}`,
+        `Provider: ${attempt.providerName || '-'}`,
+        `Successful: ${attempt.isSuccessful ? 'yes' : 'no'}`,
+        ...errorLines,
+        '',
+        'Raw provider response:',
+        formatJsonForLog(normalizedRaw),
+    ].join('\n');
+}
+
+/**
+ * Parses one contact string with the shared email parser and retains non-email identifiers verbatim.
+ */
+function createMessageContact(value: string, preferredFullName: string | null = null): MessageContact {
+    const normalizedValue = value.trim();
+
+    try {
+        const parsedAddress = parseEmailAddress(normalizedValue as string_email);
+        return {
+            fullName: preferredFullName || parsedAddress.fullName,
+            address: parsedAddress.fullEmail,
+            isEmail: true,
+        };
+    } catch {
+        return {
+            fullName: preferredFullName,
+            address: normalizedValue,
+            isEmail: false,
+        };
+    }
+}
+
+/**
+ * Reads the first non-empty string property from one JSON object.
+ */
+function readFirstStringProperty(
+    value: Record<string, Json | undefined>,
+    propertyNames: ReadonlyArray<string>,
+): string | null {
+    for (const propertyName of propertyNames) {
+        const propertyValue = value[propertyName];
+        if (typeof propertyValue === 'string' && propertyValue.trim()) {
+            return propertyValue.trim();
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Orders send attempts by their persisted timestamp and then by id.
+ */
+function compareMessageSendAttemptsChronologically(
+    firstAttempt: MessageSendAttemptRow,
+    secondAttempt: MessageSendAttemptRow,
+): number {
+    const timestampComparison = (firstAttempt.createdAt || '').localeCompare(secondAttempt.createdAt || '');
+    return timestampComparison || firstAttempt.id - secondAttempt.id;
+}
+
+/**
+ * Extracts standard serialized-error fields from legacy and current attempt payloads.
+ */
+function resolveMessageSendAttemptError(raw: unknown): MessageSendAttemptError | null {
+    const normalizedRaw = parseStoredJsonValue(raw);
+    if (typeof normalizedRaw === 'string') {
+        return normalizedRaw.trim()
+            ? {
+                  name: null,
+                  message: normalizedRaw,
+                  stack: null,
+              }
+            : null;
+    }
+
+    if (!isJsonObject(normalizedRaw)) {
+        return null;
+    }
+
+    const errorValue = parseStoredJsonValue(normalizedRaw.error ?? normalizedRaw);
+    if (typeof errorValue === 'string') {
+        return errorValue.trim()
+            ? {
+                  name: null,
+                  message: errorValue,
+                  stack: null,
+              }
+            : null;
+    }
+
+    if (!isJsonObject(errorValue) || typeof errorValue.message !== 'string' || !errorValue.message.trim()) {
+        return null;
+    }
+
+    return {
+        name: typeof errorValue.name === 'string' && errorValue.name.trim() ? errorValue.name.trim() : null,
+        message: errorValue.message.trim(),
+        stack: typeof errorValue.stack === 'string' && errorValue.stack.trim() ? errorValue.stack.trim() : null,
+    };
+}
+
+/**
+ * Parses JSON text emitted by legacy database adapters while leaving ordinary strings untouched.
+ */
+function parseStoredJsonValue(value: unknown): unknown {
+    if (typeof value !== 'string') {
+        return value;
+    }
+
+    try {
+        return JSON.parse(value) as unknown;
+    } catch {
+        return value;
+    }
+}
+
+/**
+ * Formats a persisted JSON value for a preformatted diagnostic block.
+ */
+function formatJsonForLog(value: unknown): string {
+    if (typeof value === 'string') {
+        return value;
+    }
+
+    const formattedValue = JSON.stringify(value, null, 2);
+    return formattedValue === undefined ? String(value) : formattedValue;
+}
+
+/**
+ * Checks whether an unknown value is a non-array object with string keys.
+ */
+function isJsonObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

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

@@ -21,6 +21,7 @@ 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

@@ -8,6 +8,7 @@ import { ClientVersionMismatchError } from '@promptbook-local/utils';
 import { useCallback, useEffect, useMemo, useState, type CSSProperties } from 'react';
 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 +34,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 +144,10 @@ 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],
-    );
+    const markdownInlineReferences = useAgentProjectMarkdownReferences({
+        agentPermanentId: agentName,
+        projects: projectReferences,
+    });
 
     // Error state management
     const [currentError, setCurrentError] = useState<FriendlyErrorMessage | null>(null);

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({

package/apps/agents-server/src/app/agents/[agentName]/api/book/route.ts

@@ -1,4 +1,6 @@
 import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { $provideServer } from '@/src/tools/$provideServer';
+import { scheduleAgentGoalChatModifiedNote } from '@/src/utils/agentGoalChat';
 import { $provideAgentReferenceResolver } from '@/src/utils/agentReferenceResolver/$provideAgentReferenceResolver';
 import { invalidateCachedActiveOrganizationSnapshots } from '@/src/utils/agentOrganization/loadAgentOrganizationState';
 import {
@@ -185,6 +187,12 @@ export async function PUT(request: Request, { params }: { params: Promise<{ agen
 
         const agentId = await collection.getAgentPermanentId(agentName);
         await collection.updateAgentSource(agentId, agentSource, { versionName });
+        scheduleAgentGoalChatModifiedNote({
+            agentPermanentId: agentId,
+            agentName,
+            agentSource,
+            server: await $provideServer(),
+        });
         invalidateCachedActiveOrganizationSnapshots();
         // <- TODO: [🐱‍🚀] Properly type as string_book
 

package/apps/agents-server/src/app/agents/[agentName]/api/chat/resolveAgentChatRouteContext.ts

@@ -3,8 +3,7 @@ import { computeAgentHash } from '@promptbook-local/core';
 import { resolveTeamInternalAgentAccessToken } from '../../../../../../../../src/commitments/_common/teamInternalAgentAccess';
 import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
 import { $provideOpenAiAgentKitExecutionToolsForServer } from '@/src/tools/$provideOpenAiAgentKitExecutionToolsForServer';
-import { createChatAttachmentTools } from '@/src/tools/createChatAttachmentTools';
-import { createAgentProgressTools } from '@/src/tools/createAgentProgressTools';
+import { createServerChatRuntimeTools } from '@/src/tools/createServerChatRuntimeTools';
 import { $provideAgentReferenceResolver } from '@/src/utils/agentReferenceResolver/$provideAgentReferenceResolver';
 import {
     AGENT_PREPARATION_CHAT_WAIT_TIMEOUT_MS,
@@ -25,7 +24,6 @@ import {
 } from '@/src/utils/metaDisclaimer';
 import { composePromptParametersWithMemoryContext } from '@/src/utils/memoryRuntimeContext';
 import { extractUseCalendarConnectionsFromAgentSource } from '@/src/utils/calendars/extractUseCalendarConnectionsFromAgentSource';
-import { extractUseEmailConfigurationFromAgentSource } from '@/src/utils/emails/extractUseEmailConfigurationFromAgentSource';
 import { extractProjectRepositoriesFromAgentSource } from '@/src/utils/projects/extractProjectRepositoriesFromAgentSource';
 import { resolveUseCalendarGoogleToken } from '@/src/utils/resolveUseCalendarGoogleToken';
 import { resolveUseEmailSmtpCredential } from '@/src/utils/resolveUseEmailSmtpCredential';
@@ -55,7 +53,7 @@ export type ResolvedAgentChatRouteContext = {
     message: string;
     thread?: Array<ChatMessage>;
     attachments: ChatMessage['attachments'];
-    runtimeTools: ReturnType<typeof createAgentProgressTools>;
+    runtimeTools: ReturnType<typeof createServerChatRuntimeTools>;
     promptParameters: ReturnType<typeof composePromptParametersWithMemoryContext>;
     messageSuffix: ReturnType<typeof resolveMessageSuffixFromAgentSource>;
     currentUserIdentity: ResolvedCurrentUserMemoryIdentity | null;
@@ -141,7 +139,6 @@ export async function resolveAgentChatRouteContext(
     const resolvedAgentName = resolvedAgentContext.resolvedAgentName;
     const projectRepositories = extractProjectRepositoriesFromAgentSource(agentSource);
     const calendarConnections = extractUseCalendarConnectionsFromAgentSource(agentSource);
-    const useEmailConfiguration = extractUseEmailConfigurationFromAgentSource(agentSource);
     const messageSuffix = resolveMessageSuffixFromAgentSource(agentSource);
     const incomingParameters = normalizeAgentChatIncomingParameters(rawParameters);
     const [preparedAgentModelRequirements, requestIdentities] = await Promise.all([
@@ -166,9 +163,8 @@ export async function resolveAgentChatRouteContext(
         currentUserId: currentUserIdentity?.userId,
         agentId,
         calendarConnections,
-        useEmailConfiguration,
     });
-    const runtimeTools = createAgentProgressTools(createChatAttachmentTools([], attachments));
+    const runtimeTools = createServerChatRuntimeTools(attachments);
     const promptParameters = composePromptParametersWithMemoryContext({
         baseParameters: incomingParameters,
         currentUserIdentity,
@@ -178,7 +174,6 @@ export async function resolveAgentChatRouteContext(
         projectRepositories,
         projectGithubToken,
         emailSmtpCredential,
-        emailFromAddress: useEmailConfiguration.senderEmail,
         calendarGoogleAccessToken,
         calendarConnections,
         chatAttachments: attachments,
@@ -288,9 +283,8 @@ async function resolveAgentChatCredentials(options: {
     currentUserId: number | undefined;
     agentId: string;
     calendarConnections: ReturnType<typeof extractUseCalendarConnectionsFromAgentSource>;
-    useEmailConfiguration: ReturnType<typeof extractUseEmailConfigurationFromAgentSource>;
 }): Promise<AgentChatCredentials> {
-    const { currentUserId, agentId, calendarConnections, useEmailConfiguration } = options;
+    const { currentUserId, agentId, calendarConnections } = options;
     const [projectGithubToken, calendarGoogleAccessToken, emailSmtpCredential] = await Promise.all([
         resolveUseProjectGithubToken({
             userId: currentUserId,
@@ -302,12 +296,10 @@ async function resolveAgentChatCredentials(options: {
                   agentPermanentId: agentId,
               })
             : Promise.resolve(undefined),
-        useEmailConfiguration.isEnabled
-            ? resolveUseEmailSmtpCredential({
-                  userId: currentUserId,
-                  agentPermanentId: agentId,
-              })
-            : Promise.resolve(undefined),
+        resolveUseEmailSmtpCredential({
+            userId: currentUserId,
+            agentPermanentId: agentId,
+        }),
     ]);
 
     return {