@promptbook/cli 0.114.0-0 → 0.114.0-10

package/apps/agents-server/src/utils/localChatRunner/persistLocalTeamConversations.ts

@@ -0,0 +1,71 @@
+import type { ChatMessage, ToolCall } from '@promptbook-local/types';
+import { persistFrozenUserChat } from '../userChat/persistFrozenUserChat';
+import { attachTeamMemberUserChatContext } from '../userChat/teamMemberUserChatContext';
+import { USER_CHAT_SOURCES } from '../userChat/UserChatSource';
+import type { UserChatJobRecord } from '../userChat/UserChatJobRecord';
+import type { ParsedLocalTeamConversation } from './parseLocalTeamConversations';
+
+/**
+ * Persists teammate transcripts as frozen chats and returns their chip-ready tool calls.
+ */
+export async function persistLocalTeamConversations(options: {
+    readonly job: Pick<UserChatJobRecord, 'id' | 'userId' | 'agentPermanentId' | 'chatId' | 'queuedAt'>;
+    readonly conversations: ReadonlyArray<ParsedLocalTeamConversation>;
+}): Promise<ReadonlyArray<ToolCall>> {
+    for (const conversation of options.conversations) {
+        await persistFrozenUserChat({
+            userId: options.job.userId,
+            agentPermanentId: conversation.teammate.permanentId,
+            source: USER_CHAT_SOURCES.TEAM_MEMBER,
+            chatId: createLocalTeamMemberChatId(options.job.id, conversation.transcriptFileName),
+            messages: createFrozenTeamConversationMessages(options.job, conversation),
+        });
+    }
+
+    return options.conversations.map((conversation) => conversation.toolCall);
+}
+
+/**
+ * Creates the frozen teammate-chat transcript and its primary-chat relation.
+ */
+function createFrozenTeamConversationMessages(
+    job: Pick<UserChatJobRecord, 'id' | 'agentPermanentId' | 'chatId' | 'queuedAt'>,
+    conversation: ParsedLocalTeamConversation,
+): Array<ChatMessage> {
+    const queuedAt = Date.parse(job.queuedAt);
+    const baseTimestamp = Number.isFinite(queuedAt) ? queuedAt : Date.now();
+    const transcriptIdentifier = normalizeTranscriptIdentifier(conversation.transcriptFileName);
+    const messages = conversation.conversation.map((message, index) => ({
+        id: `team-${job.id}-${transcriptIdentifier}-${index + 1}`,
+        sender: message.sender === 'AGENT' ? 'USER' : 'AGENT',
+        content: message.content,
+        isComplete: true,
+        createdAt: new Date(baseTimestamp + index * 1_000).toISOString() as NonNullable<ChatMessage['createdAt']>,
+    }));
+
+    return attachTeamMemberUserChatContext(messages, {
+        version: 1,
+        primaryAgentPermanentId: job.agentPermanentId,
+        primaryAgentName: conversation.conversation[0]?.name || 'Agent',
+        primaryChatId: job.chatId,
+    });
+}
+
+/**
+ * Creates a stable frozen-chat id so repeated synchronization refreshes the same transcript.
+ */
+function createLocalTeamMemberChatId(jobId: string, transcriptFileName: string): string {
+    return `team-${jobId}-${normalizeTranscriptIdentifier(transcriptFileName)}`;
+}
+
+/**
+ * Converts a direct transcript filename into a conservative id-safe segment.
+ */
+function normalizeTranscriptIdentifier(transcriptFileName: string): string {
+    return (
+        transcriptFileName
+            .replace(/\.book$/iu, '')
+            .replace(/[^A-Za-z0-9._-]+/gu, '-')
+            .replace(/^[._-]+|[._-]+$/gu, '') || 'conversation'
+    );
+}

package/apps/agents-server/src/utils/localChatRunner/prepareLocalTeamConversationWorkspace.ts

@@ -0,0 +1,233 @@
+import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { mkdir, rm, stat, writeFile } from 'fs/promises';
+import { join } from 'path';
+import type { string_agent_url } from '../../../../../src/types/typeAliases';
+import {
+    AGENT_TEAM_CONVERSATION_MANIFEST_FILE_NAME,
+    AGENT_TEAMMATE_SOURCES_DIRECTORY_NAME,
+    createAgentTeamConversationWorkspacePath,
+    createAgentTeamTeammateSourceFileName,
+    type AgentTeamConversationTeammate,
+    type AgentTeamConversationWorkspaceManifest,
+} from '../../../../../src/book-3.0/AgentTeamConversationWorkspace';
+import {
+    resolveCachedServerAgentContext,
+    resolveCachedServerAgentModelRequirements,
+} from '../cachedServerAgentRuntime';
+import { createServerAgentReferenceResolver } from '../agentReferenceResolver/createServerAgentReferenceResolver';
+import { normalizeLocalServerUrls, resolveLocalAgentRouteReference } from '../localAgentRouteReferences';
+import { resolveCurrentOrInternalServerOrigin } from '../resolveCurrentOrInternalServerOrigin';
+import type { UserChatJobRecord } from '../userChat/UserChatJobRecord';
+import type { LocalAgentFolder } from './ensureLocalAgentFolder';
+import type { LocalUserChatJobMetadata } from './LocalUserChatJobMetadata';
+
+/**
+ * Resolves local TEAM members and snapshots their sources for one local coding-harness job.
+ */
+export async function prepareLocalTeamConversationWorkspace(options: {
+    readonly job: Pick<UserChatJobRecord, 'agentPermanentId'>;
+    readonly agentFolder: LocalAgentFolder;
+    readonly metadata: LocalUserChatJobMetadata;
+    readonly primaryAgentName: string;
+}): Promise<void> {
+    const workspacePath = join(
+        options.agentFolder.directoryPath,
+        createAgentTeamConversationWorkspacePath(options.metadata.fileName),
+    );
+    const manifestPath = join(workspacePath, AGENT_TEAM_CONVERSATION_MANIFEST_FILE_NAME);
+
+    if (await isExistingPath(manifestPath)) {
+        return;
+    }
+
+    const localServerUrl = await resolveCurrentOrInternalServerOrigin();
+    const collection = await $provideAgentCollectionForServer();
+    const agentReferenceResolver = await createServerAgentReferenceResolver({
+        agentCollection: collection,
+        localServerUrl,
+    });
+    const primaryAgentContext = await resolveCachedServerAgentContext({
+        collection,
+        agentIdentifier: options.job.agentPermanentId,
+        localServerUrl,
+        fallbackResolver: agentReferenceResolver,
+    });
+    const preparedRequirements = await resolveCachedServerAgentModelRequirements({
+        resolvedAgentContext: primaryAgentContext,
+        localServerUrl,
+        fallbackResolver: agentReferenceResolver,
+    });
+    const teammates = await resolveLocalTeamConversationTeammates({
+        teammates: getPreparedTeamMetadata(preparedRequirements.modelRequirements._metadata?.teammates),
+        collection,
+        localServerUrl,
+        primaryAgentPermanentId: options.job.agentPermanentId,
+        agentReferenceResolver,
+    });
+
+    if (teammates.length === 0) {
+        return;
+    }
+
+    const manifest: AgentTeamConversationWorkspaceManifest = {
+        version: 1,
+        primaryAgent: {
+            permanentId: options.job.agentPermanentId,
+            agentName: options.primaryAgentName,
+        },
+        teammates: teammates.map(({ teammate }) => teammate),
+    };
+
+    // Note: The path is deterministically derived from this one queued message, so clearing a stale
+    //       incomplete workspace cannot affect another user turn.
+    await rm(workspacePath, { recursive: true, force: true });
+    await mkdir(join(workspacePath, AGENT_TEAMMATE_SOURCES_DIRECTORY_NAME), { recursive: true });
+    await Promise.all([
+        writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf-8'),
+        ...teammates.map(({ teammate, source }) =>
+            writeFile(
+                join(workspacePath, AGENT_TEAMMATE_SOURCES_DIRECTORY_NAME, teammate.sourceFileName),
+                ensureTrailingNewline(source),
+                'utf-8',
+            ),
+        ),
+    ]);
+}
+
+/**
+ * TEAM metadata retained by the TEAM commitment while building model requirements.
+ */
+type PreparedTeamMetadata = {
+    readonly url: string;
+    readonly label?: string;
+    readonly instructions?: string;
+};
+
+/**
+ * One workspace teammate paired with its resolved read-only source.
+ */
+type LocalTeamConversationTeammate = {
+    readonly teammate: AgentTeamConversationTeammate;
+    readonly source: string;
+};
+
+/**
+ * Extracts valid TEAM metadata from untyped commitment metadata.
+ */
+function getPreparedTeamMetadata(value: unknown): Array<PreparedTeamMetadata> {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+
+    return value.filter(isPreparedTeamMetadata);
+}
+
+/**
+ * Checks one TEAM metadata item from `AgentModelRequirements._metadata`.
+ */
+function isPreparedTeamMetadata(value: unknown): value is PreparedTeamMetadata {
+    return Boolean(value && typeof value === 'object' && typeof (value as PreparedTeamMetadata).url === 'string');
+}
+
+/**
+ * Resolves only teammates hosted by this Agents Server, because only their durable histories can be persisted here.
+ */
+async function resolveLocalTeamConversationTeammates(options: {
+    readonly teammates: ReadonlyArray<PreparedTeamMetadata>;
+    readonly collection: Awaited<ReturnType<typeof $provideAgentCollectionForServer>>;
+    readonly localServerUrl: string;
+    readonly primaryAgentPermanentId: string;
+    readonly agentReferenceResolver: Awaited<ReturnType<typeof createServerAgentReferenceResolver>>;
+}): Promise<Array<LocalTeamConversationTeammate>> {
+    const localServerUrls = normalizeLocalServerUrls([options.localServerUrl]);
+    const seenPermanentIds = new Set<string>();
+    const resolvedTeammates: Array<LocalTeamConversationTeammate> = [];
+
+    for (const preparedTeammate of options.teammates) {
+        const routeReference = resolveLocalAgentRouteReference(
+            preparedTeammate.url as string_agent_url,
+            localServerUrls,
+            [],
+        );
+        if (!routeReference) {
+            continue;
+        }
+
+        const basicInformation = await options.collection.findAgentBasicInformation(routeReference.agentIdentifier);
+        const teammatePermanentId = basicInformation?.permanentId;
+        if (
+            !teammatePermanentId ||
+            isSamePermanentId(teammatePermanentId, options.primaryAgentPermanentId) ||
+            seenPermanentIds.has(teammatePermanentId)
+        ) {
+            continue;
+        }
+
+        const teammateContext = await resolveCachedServerAgentContext({
+            collection: options.collection,
+            agentIdentifier: teammatePermanentId,
+            localServerUrl: options.localServerUrl,
+            fallbackResolver: options.agentReferenceResolver,
+        });
+        const teammateName = preparedTeammate.label?.trim() || teammateContext.resolvedAgentName;
+        if (!teammateName) {
+            continue;
+        }
+
+        seenPermanentIds.add(teammatePermanentId);
+        resolvedTeammates.push({
+            teammate: {
+                permanentId: teammatePermanentId,
+                agentName: teammateName,
+                url: preparedTeammate.url,
+                instructions: preparedTeammate.instructions?.trim() || '',
+                sourceFileName: createAgentTeamTeammateSourceFileName(teammatePermanentId),
+            },
+            source: teammateContext.resolvedAgentSource,
+        });
+    }
+
+    return resolvedTeammates;
+}
+
+/**
+ * Compares permanent ids case-insensitively, matching Agents Server routing semantics.
+ */
+function isSamePermanentId(firstPermanentId: string, secondPermanentId: string): boolean {
+    return firstPermanentId.toLowerCase() === secondPermanentId.toLowerCase();
+}
+
+/**
+ * Keeps source snapshots friendly to the Book parser and coding harness.
+ */
+function ensureTrailingNewline(source: string): string {
+    return source.endsWith('\n') ? source : `${source}\n`;
+}
+
+/**
+ * Checks whether a fixed per-message workspace manifest already exists.
+ */
+async function isExistingPath(path: string): Promise<boolean> {
+    try {
+        await stat(path);
+        return true;
+    } catch (error) {
+        if (isFileNotFoundError(error)) {
+            return false;
+        }
+
+        throw error;
+    }
+}
+
+/**
+ * Returns true when one filesystem error indicates a missing path.
+ */
+function isFileNotFoundError(error: unknown): boolean {
+    return Boolean(
+        error &&
+            typeof error === 'object' &&
+            'code' in error &&
+            ((error as { code?: string }).code === 'ENOENT' || (error as { code?: string }).code === 'ENOTDIR'),
+    );
+}

package/apps/agents-server/src/utils/localChatRunner/processLocalUserChatJob.ts

@@ -9,7 +9,7 @@ import {
 import { createUserChatJobFailureDetails } from '../userChat/createUserChatJobFailureDetails';
 import { claimNextQueuedUserChatJob } from '../userChat/claimNextQueuedUserChatJob';
 import { finalizeUserChatJob } from '../userChat/finalizeUserChatJob';
-import { getUserChat } from '../userChat/getUserChat';
+import { getUserChatForJobRunner } from '../userChat/getUserChatForJobRunner';
 import { getUserChatJobById } from '../userChat/getUserChatJobById';
 import { persistUserChatJobTerminalState } from '../userChat/persistUserChatJobTerminalState';
 import { provideUserChatJobTable } from '../userChat/provideUserChatJobTable';
@@ -37,6 +37,9 @@ import {
     loadLocalAgentSourceSnapshot,
     resolveLocalAgentRootPath,
 } from './ensureLocalAgentFolder';
+import { parseFinishedLocalTeamConversations } from './parseLocalTeamConversations';
+import { prepareLocalTeamConversationWorkspace } from './prepareLocalTeamConversationWorkspace';
+import { persistLocalTeamConversations } from './persistLocalTeamConversations';
 import { persistLocalUserChatJobProgressFromRuntimeLog } from './persistLocalUserChatJobProgressFromRuntimeLog';
 
 /**
@@ -145,11 +148,7 @@ async function enqueueLocalUserChatJobWithinTerminalCapture(
     job: UserChatJobRecord,
 ): Promise<ProcessLocalUserChatJobResult> {
     const [chat, agentSourceSnapshot] = await Promise.all([
-        getUserChat({
-            userId: job.userId,
-            agentPermanentId: job.agentPermanentId,
-            chatId: job.chatId,
-        }),
+        getUserChatForJobRunner(job),
         loadLocalAgentSourceSnapshot(job.agentPermanentId),
     ]);
 
@@ -186,6 +185,12 @@ async function enqueueLocalUserChatJobWithinTerminalCapture(
     });
     const queuedMessagePath = join(agentFolder.directoryPath, metadata.queuedPath);
 
+    await prepareLocalTeamConversationWorkspaceIfPossible({
+        job,
+        agentFolder,
+        metadata,
+        primaryAgentName: agentSourceSnapshot.agentName,
+    });
     await mkdir(join(agentFolder.directoryPath, 'messages', 'queued'), { recursive: true });
     await writeFile(queuedMessagePath, createLocalChatQueuedMessageBook({ messages: threadMessages }), 'utf-8');
 
@@ -207,6 +212,22 @@ async function enqueueLocalUserChatJobWithinTerminalCapture(
     return { didMutate: true, outcome: 'queued' };
 }
 
+/**
+ * Creates the optional TEAM workspace without preventing a normal answer when a teammate cannot be resolved.
+ */
+async function prepareLocalTeamConversationWorkspaceIfPossible(
+    options: Parameters<typeof prepareLocalTeamConversationWorkspace>[0],
+): Promise<void> {
+    try {
+        await prepareLocalTeamConversationWorkspace(options);
+    } catch (error) {
+        console.warn('[local-chat-runner] team_workspace_prepare_failed', {
+            agentPermanentId: options.job.agentPermanentId,
+            error,
+        });
+    }
+}
+
 /**
  * Synchronizes one already queued local job with message-folder output.
  */
@@ -225,11 +246,21 @@ async function synchronizeLocalUserChatJob(
 
         if (content) {
             await persistLocalUserChatJobRunReportIfPresent(job, agentDirectoryPath, metadata);
+            const teamConversations = await parseFinishedLocalTeamConversations({
+                agentDirectoryPath,
+                metadata,
+                job,
+            });
+            const teamToolCalls = await persistLocalTeamConversations({
+                job,
+                conversations: teamConversations,
+            });
             await persistUserChatJobTerminalState({
                 job,
                 status: 'COMPLETED',
                 provider: LOCAL_USER_CHAT_JOB_PROVIDER,
                 content,
+                toolCalls: teamToolCalls.length > 0 ? teamToolCalls : undefined,
                 generationDurationMs: resolveLocalUserChatJobDurationMs(metadata.queuedAt),
             });
             return { didMutate: true, outcome: 'completed' };

package/apps/agents-server/src/utils/manGoOnboarding/manGoOnboardingAgentBooks.ts

@@ -1,18 +1,7 @@
 import { spaceTrim } from 'spacetrim';
 
 /**
- * Agent book copied from the manGo onboarding experiment and used as the drafting specialist.
- *
- * @private internal constant of manGo onboarding agent utilities
- */
-export const MAN_GO_DRAFT_EXPERT_BOOK = spaceTrim(`
-    Book language expert
-
-    LANGUAGE Čeština
-`);
-
-/**
- * Agent book copied from the manGo onboarding experiment and used to convert free-form drafts to Book language.
+ * Agent book copied from the manGo onboarding experiment and used to generate Book language directly.
  *
  * @private internal constant of manGo onboarding agent utilities
  */
@@ -22,7 +11,7 @@ export const MAN_GO_BOOK_EXPERT_BOOK = spaceTrim(`
     PERSONA You are expert in book language
     RULE You can work with the book language and write, modify, or consult the agents based on the book language.
 
-    KNOWLEDGE https://core.ptbk.io/api/docs/book-language.md
+    KNOWLEDGE https://live.ptbk.io/api/docs/book-language.md?language=en
 
     RULE When creating agents, use code blocks with book language:
 
@@ -34,7 +23,6 @@ export const MAN_GO_BOOK_EXPERT_BOOK = spaceTrim(`
     PERSONA You are a company lawyer.
     Your job is to provide legal advice and support to the company and its employees.
     You are knowledgeable, professional, and detail-oriented.
-    USE SEARCH ENGINE
     \`\`\`
 
     RULE You are writing a book in the language the user will ask you.

package/apps/agents-server/src/utils/manGoOnboarding/manGoOnboardingAgentRuntime.ts

@@ -5,11 +5,7 @@ import { LiteAgent } from '../../../../../src/book-3.0/LiteAgent';
 import type { string_markdown } from '../../../../../src/types/string_markdown';
 import { validateBook } from '../../../../../src/book-2.0/agent-source/string_book';
 import { spaceTrim } from 'spacetrim';
-import {
-    MAN_GO_BOOK_EXPERT_BOOK,
-    MAN_GO_DRAFT_EXPERT_BOOK,
-    MAN_GO_REPLY_REVIEWER_BOOK,
-} from './manGoOnboardingAgentBooks';
+import { MAN_GO_BOOK_EXPERT_BOOK, MAN_GO_REPLY_REVIEWER_BOOK } from './manGoOnboardingAgentBooks';
 
 /**
  * Chat message accepted by the manGo onboarding test runner.
@@ -36,20 +32,13 @@ export type ManGoOnboardingReplyCheck = {
 };
 
 /**
- * Inputs used to generate the first editable Book draft.
+ * Inputs used to generate the first editable Book.
  */
-export type GenerateManGoBookDraftInput = {
+export type GenerateManGoBookInput = {
     readonly agentName: string;
     readonly agentBrief: string;
 };
 
-/**
- * Input used by the Book language conversion panel.
- */
-export type ConvertManGoDraftToBookInput = {
-    readonly input: string;
-};
-
 /**
  * Input used by the step 4 live agent test.
  */
@@ -69,7 +58,7 @@ export type EvaluateManGoAgentReplyInput = {
 };
 
 /**
- * Fallback source used when step 4 is called before the draft exists.
+ * Fallback source used when step 4 is called before the Book exists.
  *
  * @private internal constant of manGo onboarding agent utilities
  */
@@ -121,24 +110,27 @@ function extractSingleBlockContent(response: string): string {
 }
 
 /**
- * Creates a prompt that asks the imported draft expert for a real Book-language draft.
+ * Creates a prompt that asks the imported Book expert for a complete Book-language source.
  *
  * @param input - Wizard name and brief.
- * @returns Prompt for the draft expert agent.
+ * @returns Prompt for the Book expert agent.
  *
  * @private internal utility of manGo onboarding agent utilities
  */
-function createBookDraftPrompt(input: GenerateManGoBookDraftInput): string {
+function createBookPrompt(input: GenerateManGoBookInput): string {
     return spaceTrim(`
-        Write an editable Promptbook Book-language draft for an AI agent.
+        Create a complete Promptbook Book-language source for one AI agent.
 
         Return only one \`book\` code block. Do not include any explanation outside the block.
+        This source is the final editable Book.
 
         Requirements:
         - Use the provided name as the agent title.
         - Write natural-language commitments in Czech unless the brief clearly asks for another language.
-        - Include a useful PERSONA, GOAL, and practical RULE commitments derived from the brief.
+        - Include a useful PERSONA, GOAL, and practical RULE commitments derived from the description.
         - Keep commitment keywords in English.
+        - Use Book-language commitments such as WRITING SAMPLE, WRITING RULES, MESSAGE SUFFIX, and NOTE when they fit the agent.
+        - Do not use Markdown headings such as \`##\` as a substitute for Book-language commitments.
         - End the book with CLOSED.
 
         Name: ${input.agentName}
@@ -147,86 +139,42 @@ function createBookDraftPrompt(input: GenerateManGoBookDraftInput): string {
 }
 
 /**
- * Creates a first editable Book draft through the imported manGo onboarding AI agent.
+ * Creates the first editable Book through the imported manGo onboarding AI agent.
  *
  * @param input - Agent name and brief captured by the entry step.
  * @returns Editable Book source for the next wizard steps.
  */
-export async function generateManGoBookDraft(input: GenerateManGoBookDraftInput): Promise<string> {
+export async function generateManGoBook(input: GenerateManGoBookInput): Promise<string> {
     const agentName = input.agentName.trim();
     const agentBrief = input.agentBrief.trim();
 
     if (!agentName || !agentBrief) {
         throw new NotAllowed(
             spaceTrim(`
-                Cannot generate a manGo Book draft without both \`agentName\` and \`agentBrief\`.
+                Cannot generate a manGo Book without both \`agentName\` and \`agentBrief\`.
 
-                Fill in the onboarding assignment before generating the draft.
+                Fill in the onboarding assignment before generating the Book.
             `),
         );
     }
 
     const response = await runManGoLiteAgent({
-        bookSource: MAN_GO_DRAFT_EXPERT_BOOK,
-        message: createBookDraftPrompt({ agentName, agentBrief }),
+        bookSource: MAN_GO_BOOK_EXPERT_BOOK,
+        message: createBookPrompt({ agentName, agentBrief }),
     });
     const book = extractSingleBlockContent(response);
 
     if (!book) {
         throw new PipelineExecutionError(
             spaceTrim(`
-                The manGo draft expert returned an empty Book draft.
+                The manGo Book expert returned an empty Book.
 
-                Try regenerating the draft from the onboarding step.
+                Try generating the Book again from the onboarding step.
             `),
         );
     }
 
-    return book;
-}
-
-/**
- * Converts free-form draft text into canonical Book language through the imported book expert.
- *
- * @param input - Free-form editor content.
- * @returns Generated Book source and validation flag.
- */
-export async function convertManGoDraftToBook(
-    input: ConvertManGoDraftToBookInput,
-): Promise<{ readonly book: string; readonly isValid: boolean }> {
-    const normalizedInput = input.input.trim();
-
-    if (!normalizedInput) {
-        throw new NotAllowed(
-            spaceTrim(`
-                Cannot convert an empty draft to Book language.
-
-                Add draft content before running the manGo Book conversion.
-            `),
-        );
-    }
-
-    const response = await runManGoLiteAgent({
-        bookSource: MAN_GO_BOOK_EXPERT_BOOK,
-        message: spaceTrim(`
-            Create a book that defines an agent with the following input:
-
-            Wrap the output in a single \`book\` code block.
-
-            Input:
-            ${normalizedInput}
-        `),
-    });
-    const book = extractSingleBlockContent(response);
-
-    let isValid = true;
-    try {
-        validateBook(book);
-    } catch {
-        isValid = false;
-    }
-
-    return { book, isValid };
+    return validateBook(book);
 }
 
 /**

package/apps/agents-server/src/utils/messages/parseUseEmailSmtpCredential.ts

@@ -2,7 +2,7 @@ import { isValidEmail } from '../../../../../src/utils/validators/email/isValidE
 import type { SmtpMessageProviderConfiguration } from '../../message-providers/email/smtp/SmtpMessageProvider';
 
 /**
- * Normalized SMTP credential payload expected in wallet secret for USE EMAIL.
+ * Normalized SMTP credential payload expected in wallet secret for agent email.
  */
 export type UseEmailSmtpCredential = SmtpMessageProviderConfiguration & {
     fromAddress?: string;

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

@@ -4,7 +4,7 @@ import {
 } from './userWallet';
 
 /**
- * Resolves SMTP credential payload for USE EMAIL from wallet records.
+ * Resolves SMTP credential payload for agent email from wallet records.
  */
 export async function resolveUseEmailSmtpCredential(
     options: ResolveUseEmailSmtpCredentialOptions,

package/apps/agents-server/src/utils/serverManagement/createManagedServer/insertManagedServerRegistryRow.ts

@@ -22,11 +22,11 @@ export async function insertManagedServerRegistryRow(
     sqlRecorder: SqlRecorder,
 ): Promise<ServerRecord> {
     const insertRegistryResult = await client.query<Record<string, unknown>>(
-        `
+        spaceTrim(`
             INSERT INTO "${SERVER_REGISTRY_TABLE_NAME}" ("name", "environment", "domain", "tablePrefix")
             VALUES ($1, $2, $3, $4)
             RETURNING "id", "name", "environment", "domain", "tablePrefix", "createdAt", "updatedAt"
-        `,
+        `),
         [input.name, input.environment, input.domain, input.tablePrefix],
     );