@promptbook/cli 0.114.0-5 → 0.114.0-50

package/apps/agents-server/src/utils/dnsRecords/createServerDnsRecordsSections.ts

@@ -0,0 +1,58 @@
+import type { ManagedServerDnsDiagnostic } from '../../app/superadmin/servers/ServersRegistryDnsTypes';
+import { createAgentProjectsDnsRecordsSection } from '../agentProjects/createAgentProjectsDnsRecordsSection';
+import { createEmailDnsRecordsSection } from '../stalwart/createEmailDnsRecordsSection';
+import type { DnsRecordsSection } from './DnsRecordsSection';
+import { createServerDomainDnsRecordsSection } from './createServerDomainDnsRecordsSection';
+
+/**
+ * Creates every DNS section which one Agents Server needs to be fully configured.
+ *
+ * This is the single source of truth of the complete DNS setup of one server, so that `/superadmin/servers` can show
+ * the server domain, the generated project domains, and the email records in one manual and one Cloudflare wizard.
+ *
+ * @param options - Server domain, its DNS diagnostic, and the generated project domain state.
+ * @returns All DNS sections of one server.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export function createServerDnsRecordsSections(options: {
+    /**
+     * Public domain of the Agents Server.
+     */
+    readonly serverDomain: string;
+
+    /**
+     * DNS verification details of the server domain, when the deployment provides them.
+     */
+    readonly dnsDiagnostic: ManagedServerDnsDiagnostic | null | undefined;
+
+    /**
+     * Whether at least one generated project domain currently fails DNS verification.
+     */
+    readonly isProjectDnsIssue?: boolean;
+
+    /**
+     * Example generated project domain, when one is already assigned.
+     */
+    readonly projectDomain?: string | null;
+}): ReadonlyArray<DnsRecordsSection> {
+    const publicIpAddress = options.dnsDiagnostic?.publicIpAddress ?? null;
+    const serverDomainSection = createServerDomainDnsRecordsSection({
+        serverDomain: options.serverDomain,
+        dnsDiagnostic: options.dnsDiagnostic,
+    });
+
+    return [
+        ...(serverDomainSection ? [serverDomainSection] : []),
+        createAgentProjectsDnsRecordsSection({
+            isDnsIssue: options.isProjectDnsIssue,
+            projectDomain: options.projectDomain,
+            publicIpAddress,
+            serverDomain: options.serverDomain,
+        }),
+        createEmailDnsRecordsSection({
+            domain: options.serverDomain,
+            publicIpAddress,
+        }),
+    ];
+}

package/apps/agents-server/src/utils/dnsRecords/createServerDomainDnsRecordsSection.ts

@@ -0,0 +1,48 @@
+import {
+    isManagedServerDnsDiagnosticIssue,
+    type ManagedServerDnsDiagnostic,
+} from '../../app/superadmin/servers/ServersRegistryDnsTypes';
+import type { DnsRecordsSection } from './DnsRecordsSection';
+
+/**
+ * Creates the DNS section which makes the Agents Server itself reachable on its own domain.
+ *
+ * @param options - Server domain and its DNS diagnostic.
+ * @returns Server domain section, or `null` when the deployment does not verify server domains.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export function createServerDomainDnsRecordsSection(options: {
+    /**
+     * Public domain of the Agents Server.
+     */
+    readonly serverDomain: string;
+
+    /**
+     * DNS verification details of the server domain, when the deployment provides them.
+     */
+    readonly dnsDiagnostic: ManagedServerDnsDiagnostic | null | undefined;
+}): DnsRecordsSection | null {
+    const { dnsDiagnostic, serverDomain } = options;
+
+    if (!dnsDiagnostic || dnsDiagnostic.expectedRecords.length === 0) {
+        return null;
+    }
+
+    return {
+        id: 'server-domain',
+        title: `Server domain ${serverDomain}`,
+        description: `Makes the Agents Server reachable on ${serverDomain} and lets it issue its HTTPS certificate.`,
+        variants: [
+            {
+                id: 'server-domain',
+                label: 'Server domain',
+                recordSelection: 'one',
+                records: dnsDiagnostic.expectedRecords,
+            },
+        ],
+        statusSummary: dnsDiagnostic.summary,
+        resolvedAddresses: dnsDiagnostic.resolvedAddresses,
+        isDnsIssue: isManagedServerDnsDiagnosticIssue(dnsDiagnostic),
+    };
+}

package/apps/agents-server/src/utils/dnsRecords/dnsRecordGroups.ts

@@ -0,0 +1,52 @@
+import type { DnsRecordGroup } from './DnsRecordInstruction';
+
+/**
+ * Determines whether every record of every shown group has to be configured.
+ *
+ * @param recordGroups - Groups shown in one DNS manual.
+ * @returns `true` when no group offers alternatives.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export function isEveryDnsRecordGroupRequired(recordGroups: ReadonlyArray<DnsRecordGroup>): boolean {
+    return recordGroups.every((recordGroup) => recordGroup.recordSelection === 'all');
+}
+
+/**
+ * Determines whether every shown group offers alternatives out of which only one may be configured.
+ *
+ * @param recordGroups - Groups shown in one DNS manual.
+ * @returns `true` when no group requires all of its records.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export function isEveryDnsRecordGroupAlternative(recordGroups: ReadonlyArray<DnsRecordGroup>): boolean {
+    return recordGroups.every((recordGroup) => recordGroup.recordSelection === 'one');
+}
+
+/**
+ * Determines whether at least one shown group offers alternatives.
+ *
+ * Such a group can conflict with already configured records on the same hostname, so the manual has to mention
+ * removing them.
+ *
+ * @param recordGroups - Groups shown in one DNS manual.
+ * @returns `true` when at least one group offers alternatives.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export function hasAlternativeDnsRecordGroup(recordGroups: ReadonlyArray<DnsRecordGroup>): boolean {
+    return recordGroups.some((recordGroup) => recordGroup.recordSelection === 'one');
+}
+
+/**
+ * Counts all records shown in the given groups.
+ *
+ * @param recordGroups - Groups shown in one DNS manual.
+ * @returns Number of shown records.
+ *
+ * @private shared by the Agents Server DNS instruction views
+ */
+export function countDnsRecordGroupRecords(recordGroups: ReadonlyArray<DnsRecordGroup>): number {
+    return recordGroups.reduce((recordCount, recordGroup) => recordCount + recordGroup.records.length, 0);
+}

package/apps/agents-server/src/utils/dnsRecords/resolveDnsRecordBatchPlan.ts

@@ -1,4 +1,4 @@
-import type { DnsRecordInstruction, DnsRecordSelection } from './DnsRecordInstruction';
+import type { DnsRecordGroup, DnsRecordInstruction, DnsRecordSelection } from './DnsRecordInstruction';
 
 /**
  * Placeholder values like `<VPS_PUBLIC_IP>` have to be filled in by a human before the record can be created.
@@ -79,3 +79,49 @@ export function resolveDnsRecordBatchPlan(options: {
 
     return { applicableRecords, excludedRecords };
 }
+
+/**
+ * Resolves one batch plan for all groups shown in one DNS manual.
+ *
+ * Every group keeps its own all-or-one rule, so a manual which shows the server domain, the generated project
+ * domains, and the email records at once still writes exactly the records which each of these parts needs.
+ *
+ * @param recordGroups - Groups shown in one DNS manual.
+ * @returns One batch plan covering all groups without duplicated records.
+ */
+export function resolveDnsRecordBatchPlanForGroups(recordGroups: ReadonlyArray<DnsRecordGroup>): DnsRecordBatchPlan {
+    const applicableRecords: Array<DnsRecordInstruction> = [];
+    const excludedRecords: Array<ExcludedDnsRecordInstruction> = [];
+    const alreadyPlannedRecordKeys = new Set<string>();
+
+    for (const recordGroup of recordGroups) {
+        const groupBatchPlan = resolveDnsRecordBatchPlan(recordGroup);
+
+        for (const record of groupBatchPlan.applicableRecords) {
+            const recordKey = createDnsRecordKey(record);
+
+            if (alreadyPlannedRecordKeys.has(recordKey)) {
+                continue;
+            }
+
+            alreadyPlannedRecordKeys.add(recordKey);
+            applicableRecords.push(record);
+        }
+
+        excludedRecords.push(...groupBatchPlan.excludedRecords);
+    }
+
+    return { applicableRecords, excludedRecords };
+}
+
+/**
+ * Creates the identity of one DNS record used to keep the batch free of duplicates.
+ *
+ * @param record - DNS record shown in the DNS manual.
+ * @returns Case-insensitive record key.
+ *
+ * @private function of `resolveDnsRecordBatchPlanForGroups`
+ */
+function createDnsRecordKey(record: DnsRecordInstruction): string {
+    return [record.type.toUpperCase(), record.name.toLowerCase(), record.value].join('\t');
+}

package/apps/agents-server/src/utils/email/agentEmailAddress.ts

@@ -82,6 +82,20 @@ export function extractEmailAddress(value: string): string {
     return value.match(/<\s*([^>]+?)\s*>/)?.[1]?.trim() || value.trim();
 }
 
+/**
+ * Extracts and normalizes the domain of an email address.
+ */
+export function getEmailAddressDomain(value: string): string {
+    const emailAddress = extractEmailAddress(value);
+    const separatorIndex = emailAddress.lastIndexOf('@');
+
+    if (separatorIndex === -1) {
+        return '';
+    }
+
+    return normalizeEmailDomain(emailAddress.slice(separatorIndex + 1));
+}
+
 /**
  * Normalizes a mail domain for comparisons and generated addresses.
  */

package/apps/agents-server/src/utils/email/sendEmailThroughStalwart.ts

@@ -4,6 +4,7 @@ import { parseEmailAddress } from '../../message-providers/email/_common/utils/p
 import { createStalwartMessageProviderFromEnvironment } from '../../message-providers/email/stalwart/StalwartMessageProvider';
 import { sendMessage } from '../messages/sendMessage';
 import { synchronizeStalwartEmailDomain } from '../stalwart/synchronizeStalwartEmailDomain';
+import { getEmailAddressDomain } from './agentEmailAddress';
 
 /**
  * Stable provider name stored with outbound Stalwart delivery attempts.
@@ -20,7 +21,7 @@ export async function sendEmailThroughStalwart(message: OutboundEmail): Promise<
     }
 
     const senderAddress = parseEmailAddress(message.sender).fullEmail;
-    const senderDomain = senderAddress.slice(senderAddress.lastIndexOf('@') + 1).toLowerCase();
+    const senderDomain = getEmailAddressDomain(senderAddress);
     await synchronizeStalwartEmailDomain(senderDomain).catch((error) => {
         console.error('[stalwart-email]', 'pre_delivery_domain_synchronization_failed', {
             senderDomain,

package/apps/agents-server/src/utils/explicitFromCommitment.ts

@@ -0,0 +1 @@
+export * from '../../../../src/book-2.0/agent-source/explicitFromCommitment';

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/adminChatTaskSqlQuery.ts

@@ -1,3 +1,4 @@
+import { spaceTrim } from 'spacetrim';
 import type { AdminChatTaskSortField, AdminChatTaskSortOrder, AdminChatTaskView } from '../../chatTasksAdmin';
 import type { ParsedAdminChatTaskQuery } from '../parseAdminChatTaskQuery';
 
@@ -12,7 +13,7 @@ export function createAdminChatTaskBaseQuery(options: {
     userTable: string;
     agentTable: string;
 }): string {
-    return `
+    return spaceTrim(`
         SELECT
             job."id" AS "id",
             'CHAT_COMPLETION'::text AS "kind",
@@ -70,7 +71,7 @@ export function createAdminChatTaskBaseQuery(options: {
         FROM ${options.userChatTimeoutTable} timeout
         LEFT JOIN ${options.userTable} "user" ON "user"."id" = timeout."userId"
         LEFT JOIN ${options.agentTable} agent ON agent."permanentId" = timeout."agentPermanentId"
-    `;
+    `);
 }
 
 /**
@@ -85,19 +86,21 @@ export function createAdminChatTaskListQuery(options: { baseTaskQuery: string; q
     const listQueryParts = createAdminChatTaskListQueryParts(options.query);
 
     return {
-        sql: `
-            WITH tasks AS (
-                ${options.baseTaskQuery}
-            )
-            SELECT
-                task.*,
-                COUNT(*) OVER() AS "totalCount"
-            FROM tasks task
-            ${listQueryParts.whereClause}
-            ORDER BY ${createAdminChatTaskOrderBySql(options.query, 'task')}
-            LIMIT $${listQueryParts.limitPlaceholder}
-            OFFSET $${listQueryParts.offsetPlaceholder}
-        `,
+        sql: spaceTrim(
+            (block) => `
+                WITH tasks AS (
+                    ${block(options.baseTaskQuery)}
+                )
+                SELECT
+                    task.*,
+                    COUNT(*) OVER() AS "totalCount"
+                FROM tasks task
+                ${block(listQueryParts.whereClause)}
+                ORDER BY ${block(createAdminChatTaskOrderBySql(options.query, 'task'))}
+                LIMIT $${listQueryParts.limitPlaceholder}
+                OFFSET $${listQueryParts.offsetPlaceholder}
+            `,
+        ),
         values: listQueryParts.values,
     };
 }
@@ -108,23 +111,25 @@ export function createAdminChatTaskListQuery(options: { baseTaskQuery: string; q
  * @private function of `getAdminChatTasks`
  */
 export function createAdminChatTaskCountersQuery(options: { baseTaskQuery: string }): string {
-    return `
-        WITH tasks AS (
-            ${options.baseTaskQuery}
-        )
-        SELECT
-            COUNT(*) FILTER (WHERE "status" = 'RUNNING') AS "runningCount",
-            COUNT(*) FILTER (WHERE "status" = 'QUEUED') AS "queuedCount",
-            COUNT(*) FILTER (
-                WHERE "status" = 'FAILED'
-                  AND "finishedAt" >= CURRENT_TIMESTAMP - INTERVAL '24 hours'
-            ) AS "failedLast24hCount",
-            CASE
-                WHEN MIN("queuedAt") FILTER (WHERE "status" = 'QUEUED') IS NULL THEN NULL
-                ELSE EXTRACT(EPOCH FROM (CURRENT_TIMESTAMP - MIN("queuedAt") FILTER (WHERE "status" = 'QUEUED'))) * 1000
-            END AS "oldestQueuedAgeMs"
-        FROM tasks
-    `;
+    return spaceTrim(
+        (block) => `
+            WITH tasks AS (
+                ${block(options.baseTaskQuery)}
+            )
+            SELECT
+                COUNT(*) FILTER (WHERE "status" = 'RUNNING') AS "runningCount",
+                COUNT(*) FILTER (WHERE "status" = 'QUEUED') AS "queuedCount",
+                COUNT(*) FILTER (
+                    WHERE "status" = 'FAILED'
+                      AND "finishedAt" >= CURRENT_TIMESTAMP - INTERVAL '24 hours'
+                ) AS "failedLast24hCount",
+                CASE
+                    WHEN MIN("queuedAt") FILTER (WHERE "status" = 'QUEUED') IS NULL THEN NULL
+                    ELSE EXTRACT(EPOCH FROM (CURRENT_TIMESTAMP - MIN("queuedAt") FILTER (WHERE "status" = 'QUEUED'))) * 1000
+                END AS "oldestQueuedAgeMs"
+            FROM tasks
+        `,
+    );
 }
 
 /**
@@ -265,7 +270,7 @@ function createAdminChatTaskDefaultOrderBySql(view: AdminChatTaskView, alias: st
             return `${createAdminChatTaskTimelineExpressionSql(alias)} DESC NULLS LAST, ${alias}."updatedAt" DESC, ${alias}."createdAt" DESC, ${alias}."id" DESC`;
         case 'active':
         default:
-            return `
+            return spaceTrim(`
                 CASE
                     WHEN ${alias}."status" = 'RUNNING' THEN 0
                     WHEN ${alias}."status" = 'QUEUED' THEN 1
@@ -281,7 +286,7 @@ function createAdminChatTaskDefaultOrderBySql(view: AdminChatTaskView, alias: st
                 END DESC NULLS LAST,
                 ${alias}."updatedAt" DESC,
                 ${alias}."id" DESC
-            `;
+            `);
     }
 }
 
@@ -328,13 +333,13 @@ function createAdminChatTaskCustomOrderBySql(
  * @private function of `getAdminChatTasks`
  */
 function createAdminChatTaskTimelineExpressionSql(alias: string): string {
-    return `
+    return spaceTrim(`
         CASE
             WHEN ${alias}."status" = 'RUNNING' THEN COALESCE(${alias}."startedAt", ${alias}."createdAt")
             WHEN ${alias}."status" = 'QUEUED' THEN ${alias}."createdAt"
             ELSE COALESCE(${alias}."finishedAt", ${alias}."updatedAt", ${alias}."createdAt")
         END
-    `;
+    `);
 }
 
 /**

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/loadAdminChatTaskFallbackData.ts

@@ -1,6 +1,4 @@
-import { $getTableName } from '@/src/database/$getTableName';
-import { $provideSupabaseForServer } from '@/src/database/$provideSupabaseForServer';
-import type { AgentsServerDatabase } from '@/src/database/schema';
+import { loadAgentNamesByPermanentId, loadUsernamesByUserId } from '../../adminEntityLookups';
 import { provideUserChatJobTable } from '../../userChat/provideUserChatJobTable';
 import type { UserChatJobStatus } from '../../userChat/UserChatJobRecord';
 import { provideUserChatTimeoutTable } from '../../userChatTimeout/userChatTimeoutStore/provideUserChatTimeoutTable';
@@ -54,23 +52,6 @@ export type AdminChatTaskTimeoutRow = {
     status: UserChatJobStatus;
 };
 
-/**
- * Minimal user lookup row needed by the admin task-manager fallback.
- *
- * @private type of `getAdminChatTasks`
- */
-type AdminChatTaskUserLookupRow = Pick<AgentsServerDatabase['public']['Tables']['User']['Row'], 'id' | 'username'>;
-
-/**
- * Minimal agent lookup row needed by the admin task-manager fallback.
- *
- * @private type of `getAdminChatTasks`
- */
-type AdminChatTaskAgentLookupRow = Pick<
-    AgentsServerDatabase['public']['Tables']['Agent']['Row'],
-    'permanentId' | 'agentName'
->;
-
 /**
  * Raw admin task-manager rows and lookup maps loaded through the Supabase-shaped adapters used by SQLite mode.
  *
@@ -95,8 +76,8 @@ export async function loadAdminChatTaskFallbackData(): Promise<AdminChatTaskFall
         ...new Set([...jobRows, ...timeoutRows].map((task) => task.agentPermanentId).filter(Boolean)),
     ];
     const [usernamesById, agentNamesByPermanentId] = await Promise.all([
-        loadAdminChatTaskUsernames(allUserIds),
-        loadAdminChatTaskAgentNames(allAgentPermanentIds),
+        loadUsernamesByUserId(allUserIds),
+        loadAgentNamesByPermanentId(allAgentPermanentIds),
     ]);
 
     return { jobRows, timeoutRows, usernamesById, agentNamesByPermanentId };
@@ -137,58 +118,3 @@ async function loadAdminChatTaskTimeoutRows(): Promise<Array<AdminChatTaskTimeou
 
     return (data || []) as unknown as Array<AdminChatTaskTimeoutRow>;
 }
-
-/**
- * Loads usernames keyed by user id for admin task rendering and search.
- *
- * @private function of `getAdminChatTasks`
- */
-async function loadAdminChatTaskUsernames(userIds: ReadonlyArray<number>): Promise<Map<number, string>> {
-    if (userIds.length === 0) {
-        return new Map();
-    }
-
-    const supabase = $provideSupabaseForServer();
-    const userTable = await $getTableName('User');
-    const { data, error } = await supabase.from(userTable).select('id,username').in('id', [...new Set(userIds)]);
-
-    if (error) {
-        throw new Error(`Failed to load admin task-manager users: ${error.message}`);
-    }
-
-    return new Map(
-        ((data || []) as Array<AdminChatTaskUserLookupRow>).map((userRow) => [userRow.id, userRow.username] as const),
-    );
-}
-
-/**
- * Loads agent names keyed by permanent id for admin task rendering and search.
- *
- * @private function of `getAdminChatTasks`
- */
-async function loadAdminChatTaskAgentNames(
-    agentPermanentIds: ReadonlyArray<string>,
-): Promise<Map<string, string | null>> {
-    if (agentPermanentIds.length === 0) {
-        return new Map();
-    }
-
-    const supabase = $provideSupabaseForServer();
-    const agentTable = await $getTableName('Agent');
-    const { data, error } = await supabase
-        .from(agentTable)
-        .select('permanentId,agentName')
-        .in('permanentId', [...new Set(agentPermanentIds)]);
-
-    if (error) {
-        throw new Error(`Failed to load admin task-manager agents: ${error.message}`);
-    }
-
-    return new Map(
-        ((data || []) as Array<AdminChatTaskAgentLookupRow>)
-            .filter((agentRow): agentRow is AdminChatTaskAgentLookupRow & { permanentId: string } =>
-                Boolean(agentRow.permanentId),
-            )
-            .map((agentRow) => [agentRow.permanentId, agentRow.agentName] as const),
-    );
-}

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/mapAdminChatTaskFallbackRows.ts

@@ -1,3 +1,4 @@
+import { isAgentGoalChatId } from '../../agentGoalChat/agentGoalChatIdentity';
 import type { AdminChatTaskRecord } from '../../chatTasksAdmin';
 import { getUserChatJobRunReportFromParameters } from '../../userChat/userChatJobRunReport';
 import { resolveNullableSqlNumber } from './adminChatTaskSqlValues';
@@ -57,6 +58,7 @@ function mapAdminChatTaskJobRow(
         chatId: row.chatId,
         workerId: null,
         queueName: 'user-chat-jobs',
+        isAgentGoalTask: isAgentGoalChatId(row.chatId),
         runReport: getUserChatJobRunReportFromParameters(row.parameters),
     };
 }
@@ -97,5 +99,6 @@ function mapAdminChatTaskTimeoutRow(
         chatId: row.chatId,
         workerId: null,
         queueName: 'user-chat-timeouts',
+        isAgentGoalTask: isAgentGoalChatId(row.chatId),
     };
 }

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/mapAdminChatTaskSqlRows.ts

@@ -1,3 +1,4 @@
+import { isAgentGoalChatId } from '../../agentGoalChat/agentGoalChatIdentity';
 import type { AdminChatTaskCounters, AdminChatTaskRecord } from '../../chatTasksAdmin';
 import type { UserChatJobStatus } from '../../userChat/UserChatJobRecord';
 import { getUserChatJobRunReportFromParameters } from '../../userChat/userChatJobRunReport';
@@ -79,6 +80,7 @@ export function mapAdminChatTaskSqlRow(row: AdminChatTaskSqlRow): AdminChatTaskR
         chatId: row.chatId,
         workerId: null,
         queueName: row.queueName,
+        isAgentGoalTask: isAgentGoalChatId(row.chatId),
         runReport: getUserChatJobRunReportFromParameters(row.parameters),
     };
 }

package/apps/agents-server/src/utils/getFederatedServers.ts

@@ -1,24 +1,14 @@
-import { string_promptbook_server_url } from '@promptbook-local/types';
+import type { string_promptbook_server_url } from '@promptbook-local/types';
+import { FEDERATED_SERVERS_METADATA_KEY } from '../constants/federatedAgentImport';
 import { getMetadataMap } from '../database/getMetadata';
-
-/**
- * Metadata key storing the comma-separated federated servers list.
- *
- * @private
- */
-const FEDERATED_SERVERS_METADATA_KEY = 'FEDERATED_SERVERS';
+import { parseFederatedServers } from './parseFederatedServers';
 
 /**
  * Reads FEDERATED_SERVERS metadata and returns a normalized list of server URLs.
  *
  * @public exported from `apps/agents-server`
  */
-export async function getFederatedServers(): Promise<string_promptbook_server_url[]> {
+export async function getFederatedServers(): Promise<Array<string_promptbook_server_url>> {
     const metadata = await getMetadataMap([FEDERATED_SERVERS_METADATA_KEY]);
-    const federatedServersString = metadata[FEDERATED_SERVERS_METADATA_KEY] || '';
-
-    return federatedServersString
-        .split(',')
-        .map((server) => server.trim())
-        .filter((server): server is string_promptbook_server_url => server !== '');
+    return parseFederatedServers(metadata[FEDERATED_SERVERS_METADATA_KEY]);
 }

package/apps/agents-server/src/utils/getWellKnownAgentUrl.ts

@@ -1,5 +1,6 @@
 import { CORE_AGENTS_SERVER_WELL_KNOWN_AGENT_NAMES } from '../../../../servers';
 import { string_agent_url } from '../../../../src/_packages/types.index'; // <- [🚾]
+import { createWellKnownAgentUrl } from './createWellKnownAgentUrl';
 import { resolveCurrentOrInternalServerOrigin } from './resolveCurrentOrInternalServerOrigin';
 
 /**
@@ -14,7 +15,5 @@ export async function getWellKnownAgentUrl(
     agentName: keyof typeof CORE_AGENTS_SERVER_WELL_KNOWN_AGENT_NAMES,
 ): Promise<string_agent_url> {
     const localServerOrigin = await resolveCurrentOrInternalServerOrigin();
-    const normalizedServerOrigin = localServerOrigin.replace(/\/+$/g, '');
-
-    return `${normalizedServerOrigin}/agents/${CORE_AGENTS_SERVER_WELL_KNOWN_AGENT_NAMES[agentName]}` as string_agent_url;
+    return createWellKnownAgentUrl(localServerOrigin, agentName);
 }

package/apps/agents-server/src/utils/handleChatCompletion/createHandleChatCompletionPromptContext.ts

@@ -1,5 +1,6 @@
 import { createChatHistoryRecorder } from '@/src/utils/chat/createChatHistoryRecorder';
 import { composePromptParametersWithMemoryContext } from '@/src/utils/memoryRuntimeContext';
+import { createAgentGoalChatTimeoutTools } from '@/src/tools/agentGoalChatTimeoutTools';
 import type { ChatMessage, ChatPrompt } from '@promptbook-local/types';
 import { $getCurrentDate } from '@promptbook-local/utils';
 import type { NextRequest } from 'next/server';
@@ -69,6 +70,7 @@ export async function createHandleChatCompletionPromptContext(options: {
         localServerUrl: runtime.localServerUrl,
         teamInternalAccessToken: resolveTeamInternalAgentAccessToken(),
     });
+    const runtimeTools = createAgentGoalChatTimeoutTools(parsedRequest.runtimeTools || []);
     const prompt: ChatPrompt = {
         title,
         content: lastMessage.content,
@@ -79,7 +81,7 @@ export async function createHandleChatCompletionPromptContext(options: {
         },
         parameters: promptParameters,
         thread,
-        ...(parsedRequest.runtimeTools ? { tools: parsedRequest.runtimeTools } : {}),
+        tools: runtimeTools,
     };
 
     return {