@promptbook/cli 0.112.0-99 → 0.112.0

package/apps/agents-server/src/utils/transpilers/resolveTranspiledTeamExport.ts

@@ -1,4 +1,5 @@
 import { createAgentModelRequirements, parseAgentSource } from '@promptbook-local/core';
+import { spaceTrim } from 'spacetrim';
 import type { AgentReferenceResolver } from '../../../../../src/book-2.0/agent-source/AgentReferenceResolver';
 import { resolvePseudoAgentKindFromUrl } from '../../../../../src/book-2.0/agent-source/pseudoAgentReferences';
 import type { string_book } from '../../../../../src/book-2.0/agent-source/string_book';
@@ -140,15 +141,9 @@ async function createTranspiledTeamAgentFromSource(options: {
     readonly agentReferenceResolver: AgentReferenceResolver;
     readonly isRootAgent: boolean;
 }): Promise<TranspiledTeamAgent> {
-    const modelRequirements = await createAgentModelRequirements(
-        options.agentSource,
-        undefined,
-        undefined,
-        undefined,
-        {
-            agentReferenceResolver: options.agentReferenceResolver,
-        },
-    );
+    const modelRequirements = await createAgentModelRequirements(options.agentSource, undefined, undefined, undefined, {
+        agentReferenceResolver: options.agentReferenceResolver,
+    });
     const parsedAgentSource = parseAgentSource(options.agentSource);
     const agentName = parsedAgentSource.agentName || options.agentUrl;
 
@@ -174,7 +169,12 @@ function createPseudoTranspiledTeamAgent(teammate: TranspiledTeamTeammate): Tran
         pseudoAgentKind === 'USER'
             ? 'This pseudo-agent represents the human user. Ask for exactly one reply from the user.'
             : 'This pseudo-agent represents silence and intentionally does not answer.';
-    const agentSource = `${teammate.label}\n\nNOTE Built-in ${pseudoAgentKind || 'pseudo'} TEAM pseudo-agent.\nCLOSED`;
+    const agentSource = spaceTrim(`
+        ${teammate.label}
+
+        NOTE Built-in ${pseudoAgentKind || 'pseudo'} TEAM pseudo-agent.
+        CLOSED
+    `);
 
     return {
         url: teammate.url,

package/apps/agents-server/src/utils/upload/createBookEditorUploadHandler.ts

@@ -1,22 +1,20 @@
 'use client';
 
-import { upload } from '@vercel/blob/client';
-import type { number_percent, string_knowledge_source_content } from '@promptbook-local/types';
+import type { string_knowledge_source_content } from '@promptbook-local/types';
 import { getSafeCdnPath } from '../cdn/utils/getSafeCdnPath';
 import { normalizeUploadFilename } from '../normalization/normalizeUploadFilename';
+import {
+    buildDefaultUserFileUploadPath,
+    uploadFileToServer,
+    type FileUploadProgressCallback,
+} from './uploadFileToServer';
 
 /**
  * Progress callback invoked during file uploads.
  *
  * @private used by chat and book editors.
  */
-export type FileUploadProgressCallback = (
-    progress: number_percent,
-    stats?: {
-        loadedBytes: number;
-        totalBytes: number;
-    },
-) => void;
+export type { FileUploadProgressCallback };
 
 /**
  * Optional upload configuration such as progress reporting or cancellation.
@@ -55,8 +53,8 @@ type UploadPathBuilder = (normalizedFilename: string, pathPrefix: string) => str
 /**
  * Constant for build default user file path.
  */
-const buildDefaultUserFilePath: UploadPathBuilder = (normalizedFilename, pathPrefix) =>
-    pathPrefix ? `${pathPrefix}/user/files/${normalizedFilename}` : `user/files/${normalizedFilename}`;
+const buildDefaultUserFilePath: UploadPathBuilder = (normalizedFilename) =>
+    buildDefaultUserFileUploadPath(normalizedFilename);
 
 /**
  * Configuration of the shared upload handler.
@@ -95,33 +93,26 @@ export function createFileUploadHandler<ReturnType extends string = string>(
         const pathPrefix = process.env.NEXT_PUBLIC_CDN_PATH_PREFIX || '';
         const normalizedFilename = normalizeUploadFilename(file.name);
         const uploadPath = pathBuilder(normalizedFilename, pathPrefix);
-        const safeUploadPath = getSafeCdnPath({ pathname: uploadPath });
-
-        const blob = await upload(safeUploadPath, file, {
-            access: 'public',
-            handleUploadUrl: '/api/upload',
-            clientPayload: JSON.stringify({
-                purpose,
-                contentType: file.type || 'application/octet-stream',
-            }),
+        const safeUploadPath = getSafeCdnPath({ pathname: uploadPath, pathPrefix });
+
+        const uploadResult = await uploadFileToServer({
+            file,
+            pathname: safeUploadPath,
+            purpose,
+            contentType: file.type || 'application/octet-stream',
             abortSignal,
-            onUploadProgress: (progressEvent) => {
-                onProgress?.(progressEvent.percentage / 100, {
-                    loadedBytes: progressEvent.loaded,
-                    totalBytes: progressEvent.total,
-                });
-            },
+            onProgress,
         });
 
         if (returnShortUrl && process.env.NEXT_PUBLIC_CDN_PUBLIC_URL) {
             const slashIndex = uploadPath.lastIndexOf('/');
             const directoryPath = slashIndex === -1 ? '' : `${uploadPath.slice(0, slashIndex + 1)}`;
             const longUrlPrefix = `${process.env.NEXT_PUBLIC_CDN_PUBLIC_URL}/${directoryPath}`;
-            const shortUrl = blob.url.split(longUrlPrefix).join(shortUrlPrefix);
+            const shortUrl = uploadResult.url.split(longUrlPrefix).join(shortUrlPrefix);
             return shortUrl as ReturnType;
         }
 
-        return blob.url as ReturnType;
+        return uploadResult.url as ReturnType;
     };
 }
 

package/apps/agents-server/src/utils/upload/fileUploadAvailability.ts

@@ -0,0 +1,91 @@
+/**
+ * Message shown when self-contained file uploads cannot safely choose a serving domain.
+ */
+export const FILE_UPLOAD_REQUIRES_SERVER_DOMAIN_MESSAGE =
+    'Create the first server/domain before uploading files. Uploaded files are served from the current server domain, and raw-IP bootstrap access does not have one yet.';
+
+/**
+ * Browser-safe upload availability state.
+ */
+export type FileUploadAvailability = {
+    /**
+     * Whether file uploads may be accepted for the current request.
+     */
+    readonly isUploadAvailable: boolean;
+
+    /**
+     * User-facing reason shown when uploads are unavailable.
+     */
+    readonly message: string | null;
+};
+
+/**
+ * Inputs used to resolve whether uploads are allowed for the current server.
+ */
+export type ResolveFileUploadAvailabilityOptions = {
+    /**
+     * Current server id, or `null` before a request is matched to a server/domain.
+     */
+    readonly serverId: number | null;
+
+    /**
+     * Public URL resolved for the current request.
+     */
+    readonly serverPublicUrl: URL;
+
+    /**
+     * Whether the deployment is using the bundled self-contained S3 storage.
+     */
+    readonly isSelfContainedS3StorageSelected: boolean;
+};
+
+/**
+ * Default upload availability used when no server-side context is available.
+ */
+export const AVAILABLE_FILE_UPLOAD: FileUploadAvailability = {
+    isUploadAvailable: true,
+    message: null,
+};
+
+/**
+ * Resolves whether file uploads can be accepted for the current request.
+ *
+ * Self-contained S3 publishes files through the current server domain. While the
+ * standalone VPS is still being accessed as a bootstrap/default server, there is
+ * no server-specific domain to publish under, so uploads must be disabled.
+ *
+ * @param options - Current server and storage mode.
+ * @returns Browser-safe upload availability state.
+ */
+export function resolveFileUploadAvailability(
+    options: ResolveFileUploadAvailabilityOptions,
+): FileUploadAvailability {
+    if (!options.isSelfContainedS3StorageSelected) {
+        return AVAILABLE_FILE_UPLOAD;
+    }
+
+    if (options.serverId !== null) {
+        return AVAILABLE_FILE_UPLOAD;
+    }
+
+    if (isLocalDevelopmentUrl(options.serverPublicUrl)) {
+        return AVAILABLE_FILE_UPLOAD;
+    }
+
+    return {
+        isUploadAvailable: false,
+        message: FILE_UPLOAD_REQUIRES_SERVER_DOMAIN_MESSAGE,
+    };
+}
+
+/**
+ * Checks whether a server URL points to local development.
+ *
+ * @param serverPublicUrl - Public URL resolved for the current request.
+ * @returns `true` for localhost and loopback hosts.
+ */
+function isLocalDevelopmentUrl(serverPublicUrl: URL): boolean {
+    const hostname = serverPublicUrl.hostname.toLowerCase();
+
+    return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '::1';
+}

package/apps/agents-server/src/utils/upload/uploadFileToServer.ts

@@ -0,0 +1,157 @@
+'use client';
+
+import type { number_percent } from '@promptbook-local/types';
+
+/**
+ * Progress callback invoked during file uploads.
+ *
+ * @private used by chat, book editor, and admin upload surfaces.
+ */
+export type FileUploadProgressCallback = (
+    progress: number_percent,
+    stats?: {
+        loadedBytes: number;
+        totalBytes: number;
+    },
+) => void;
+
+/**
+ * Options for uploading one file through the Agents Server upload endpoint.
+ *
+ * @private used by browser upload helpers.
+ */
+export type ServerFileUploadOptions = {
+    file: File;
+    pathname: string;
+    purpose?: string;
+    contentType?: string;
+    abortSignal?: AbortSignal;
+    onProgress?: FileUploadProgressCallback;
+};
+
+/**
+ * Response returned by the Agents Server upload endpoint.
+ *
+ * @private used by browser upload helpers.
+ */
+export type ServerFileUploadResult = {
+    url: string;
+    pathname: string;
+    contentType: string;
+    size: number;
+};
+
+/**
+ * Error response shape accepted from the upload endpoint.
+ *
+ * @private used by `uploadFileToServer`
+ */
+type ServerFileUploadErrorResponse = {
+    error?: string | { message?: string };
+    message?: string;
+};
+
+/**
+ * Builds the default CDN key used for user-uploaded files.
+ *
+ * @private shared by browser upload surfaces.
+ */
+export function buildDefaultUserFileUploadPath(normalizedFilename: string): string {
+    return `user/files/${normalizedFilename}`;
+}
+
+/**
+ * Resolves the most useful error message from an upload response body.
+ *
+ * @param responseBody - Parsed JSON response body.
+ * @param status - HTTP status code.
+ * @returns Error message for the rejected upload promise.
+ * @private helper of `uploadFileToServer`
+ */
+function resolveUploadErrorMessage(
+    responseBody: (Partial<ServerFileUploadResult> & ServerFileUploadErrorResponse) | null,
+    status: number,
+): string {
+    if (typeof responseBody?.error === 'string' && responseBody.error) {
+        return responseBody.error;
+    }
+
+    if (
+        typeof responseBody?.error === 'object' &&
+        responseBody.error !== null &&
+        typeof responseBody.error.message === 'string' &&
+        responseBody.error.message
+    ) {
+        return responseBody.error.message;
+    }
+
+    if (typeof responseBody?.message === 'string' && responseBody.message) {
+        return responseBody.message;
+    }
+
+    return `File upload failed with HTTP ${status}.`;
+}
+
+/**
+ * Uploads one browser file to `/api/upload` using normal multipart form data.
+ *
+ * @private shared by browser upload surfaces.
+ */
+export function uploadFileToServer(options: ServerFileUploadOptions): Promise<ServerFileUploadResult> {
+    const { file, pathname, purpose = 'GENERIC_UPLOAD', contentType = file.type || 'application/octet-stream' } = options;
+
+    return new Promise((resolve, reject) => {
+        const request = new XMLHttpRequest();
+        const formData = new FormData();
+
+        formData.append('file', file);
+        formData.append('pathname', pathname);
+        formData.append('purpose', purpose);
+        formData.append('contentType', contentType);
+
+        request.open('POST', '/api/upload');
+        request.responseType = 'json';
+
+        request.upload.onprogress = (event) => {
+            if (!event.lengthComputable || !options.onProgress) {
+                return;
+            }
+
+            options.onProgress(event.loaded / event.total, {
+                loadedBytes: event.loaded,
+                totalBytes: event.total,
+            });
+        };
+
+        request.onload = () => {
+            const responseBody = request.response as
+                | (Partial<ServerFileUploadResult> & ServerFileUploadErrorResponse)
+                | null;
+
+            if (request.status >= 200 && request.status < 300 && responseBody?.url) {
+                options.onProgress?.(1 as number_percent, {
+                    loadedBytes: file.size,
+                    totalBytes: file.size,
+                });
+
+                resolve(responseBody as ServerFileUploadResult);
+                return;
+            }
+
+            reject(new Error(resolveUploadErrorMessage(responseBody, request.status)));
+        };
+
+        request.onerror = () => reject(new Error('File upload failed.'));
+        request.onabort = () => reject(new DOMException('File upload was aborted.', 'AbortError'));
+
+        options.abortSignal?.addEventListener(
+            'abort',
+            () => {
+                request.abort();
+            },
+            { once: true },
+        );
+
+        request.send(formData);
+    });
+}

package/apps/agents-server/src/utils/userChat/createImmediateUserChatAnswerModelRequirements.ts

@@ -5,7 +5,7 @@ import { parseAgentSourceWithCommitments } from '../../../../../src/book-2.0/age
 import type { string_book } from '../../../../../src/book-2.0/agent-source/string_book';
 
 /**
- * Commitments safe to use in the immediate answer without triggering slow tools, knowledge, imports, or memory.
+ * Commitments safe to use in the immediate pre-answer without triggering slow tools, knowledge, imports, or memory.
  */
 const IMMEDIATE_USER_CHAT_ANSWER_INSTRUCTION_COMMITMENTS = new Set<string>([
     'PERSONA',
@@ -26,27 +26,41 @@ const IMMEDIATE_USER_CHAT_ANSWER_INSTRUCTION_COMMITMENTS = new Set<string>([
 ]);
 
 /**
- * Prefix added to the immediate answer system message.
+ * Prefix added to the immediate pre-answer system message.
  */
 const IMMEDIATE_USER_CHAT_ANSWER_SYSTEM_PREAMBLE = spaceTrim(`
-    You are preparing a fast draft answer for the user while a slower full agent run continues separately.
-    This response is not the final answer.
-    These immediate-answer rules override any agent instruction below that would make the answer sound final.
+    
+    You are preparing a short in-progress confirmation for the user while a slower full agent run continues separately.
+
+    This response is not the final answer. It is only a confirmation that the task is being handled.
+    These immediate-answer rules override any agent instruction below that would make the answer sound final or complete.
 
     At the start of every response, clearly say in the user's language:
-    - This is only a draft or preliminary answer, not the final answer.
-    - The final answer will arrive in several minutes after the external service finishes processing.
-    - The final answer can change or correct this draft, so the user should not treat this draft as final.
+    - You understood what the user wants.
+    - You are working on it now or the job has already started.
+    - The final answer will arrive after the background processing finishes.
+    - You can use Markdown formatting in the messages like **bold** or *italic*
 
-    After that notice, give a brief useful draft of what is happening or the likely answer.
+    Keep the whole response short, preferably one or two sentences.
+    Do not provide any part of the final answer yet.
+    Do not include code snippets, detailed steps, calculations, drafted content, likely conclusions, or partial deliverables.
+    If helpful, briefly name the kind of work being done, such as writing code, checking something, preparing an answer, or generating an image.
     Answer directly and use only the instructions, conversation, attachments, and general model knowledge available in this request.
     Do not use or claim to have used external tools, memory, knowledge bases, web browsing, search, calendar, email, projects, or teammate agents.
-    Never present this draft as complete or definitive.
-    If the user asks for something that clearly requires those unavailable capabilities, explain that the checked final answer is still being prepared.
+    Never present this message as complete, definitive, or ready to use.
+    If the user asks for something that clearly requires unavailable capabilities, simply say the checked final answer is still being prepared.
+
+
+    Example of a good immediate pre-answer response:
+
+    \`\`\`markdown
+    xxx
+    \`\`\`
+
 `);
 
 /**
- * Creates the lightweight model requirements used by the immediate answer path.
+ * Creates the lightweight model requirements used by the immediate pre-answer path.
  */
 export function createImmediateUserChatAnswerModelRequirements(
     agentSource: string_book,

package/apps/agents-server/src/utils/userChat/createRunUserChatJobExecutionContext.ts

@@ -27,6 +27,8 @@ import type { ChatMessage, ChatPrompt, LlmToolDefinition, ToolCall } from '@prom
 import { resolveTeamInternalAgentAccessToken } from '../../../../../src/commitments/_common/teamInternalAgentAccess';
 import type { ChatPromptResult } from '../../../../../src/execution/PromptResult';
 import { createUserChatMessagePrompt } from './createUserChatMessagePrompt';
+import { resolveUserChatProgressToolHighlights } from './resolveUserChatProgressToolHighlights';
+import type { UserChatProgressContext, UserChatProgressPhase } from './userChatProgressCard';
 import type { UserChatJobRecord } from './UserChatJobRecord';
 
 /**
@@ -53,6 +55,15 @@ type RunUserChatJobPromptSnapshotFactory = (
     },
 ) => NonNullable<ChatMessage['prompt']>;
 
+/**
+ * Reports one user-facing durable chat progress phase together with the real runtime
+ * details already known at that point in the worker lifecycle.
+ */
+type RunUserChatJobProgressReporter = (
+    phase: UserChatProgressPhase,
+    context?: UserChatProgressContext,
+) => Promise<void>;
+
 /**
  * Prepares the full agent/runtime context required to execute one durable user chat job.
  *
@@ -67,12 +78,23 @@ export async function createRunUserChatJobExecutionContext(options: {
     userMessageAttachments: ChatMessage['attachments'];
     thread: NonNullable<ChatPrompt['thread']>;
     promptContent: ChatPrompt['content'];
+    reportProgress?: RunUserChatJobProgressReporter;
 }) {
+    const initialProgressContext: UserChatProgressContext = {
+        agentPermanentId: options.job.agentPermanentId,
+        attachmentCount: options.userMessageAttachments?.length ?? 0,
+    };
+
+    await options.reportProgress?.('reading_context', initialProgressContext);
+
     const [localServerUrl, collection, baseAgentReferenceResolver] = await Promise.all([
         resolveCurrentOrInternalServerOrigin(),
         $provideAgentCollectionForServer(),
         $provideAgentReferenceResolver(),
     ]);
+
+    await options.reportProgress?.('preparing_agent', initialProgressContext);
+
     const resolvedAgentContext = await resolveCachedServerAgentContext({
         collection,
         agentIdentifier: options.job.agentPermanentId,
@@ -91,6 +113,23 @@ export async function createRunUserChatJobExecutionContext(options: {
     const projectRepositories = extractProjectRepositoriesFromAgentSource(agentSource);
     const calendarConnections = extractUseCalendarConnectionsFromAgentSource(agentSource);
     const useEmailConfiguration = extractUseEmailConfigurationFromAgentSource(agentSource);
+    const agentToolDefinitions = preparedAgentModelRequirements.modelRequirements.tools ?? [];
+    const agentKnowledgeSources = preparedAgentModelRequirements.modelRequirements.knowledgeSources ?? [];
+
+    const checkingCapabilitiesProgressContext: UserChatProgressContext = {
+        ...initialProgressContext,
+        agentName: resolvedAgentName,
+        agentPermanentId,
+        knowledgeSourceCount: agentKnowledgeSources.length,
+        toolCount: agentToolDefinitions.length,
+        toolHighlights: resolveUserChatProgressToolHighlights(agentToolDefinitions),
+        hasCalendarAccess: calendarConnections.length > 0,
+        hasEmailAccess: useEmailConfiguration.isEnabled,
+        hasProjectAccess: projectRepositories.length > 0,
+    };
+
+    await options.reportProgress?.('checking_capabilities', checkingCapabilitiesProgressContext);
+
     const { projectGithubToken, calendarGoogleAccessToken, emailSmtpCredential } =
         await resolveRunUserChatJobCredentials({
             userId: options.job.userId,
@@ -186,6 +225,12 @@ export async function createRunUserChatJobExecutionContext(options: {
         teacherAgent: await getTeacherRemoteAgent(),
     });
 
+    await options.reportProgress?.('starting_response', {
+        ...checkingCapabilitiesProgressContext,
+        provider: provider ?? undefined,
+        isAgentKitCached: agentKitResult.fromCache,
+    });
+
     return {
         collection,
         agent,

package/apps/agents-server/src/utils/userChat/createRunUserChatJobPersistenceController.ts

@@ -2,6 +2,7 @@ import { prepareToolCallsForStreaming } from '@/src/utils/toolCallStreaming';
 import type { ChatMessage, LlmToolDefinition, ToolCall } from '@promptbook-local/types';
 import type { ChatPromptResult } from '../../../../../src/execution/PromptResult';
 import { mergeToolCalls } from '../../../../../src/utils/toolCalls/mergeToolCalls';
+import { createUserChatHarnessProgressCard } from './createUserChatHarnessProgressCard';
 import { persistUserChatJobTerminalState } from './persistUserChatJobTerminalState';
 import { updateUserChatAssistantMessage } from './updateUserChatAssistantMessage';
 import { USER_CHAT_JOB_ASSISTANT_MESSAGE_PERSIST_INTERVAL_MS } from './userChatJobRuntimeConstants';
@@ -125,17 +126,22 @@ export function createRunUserChatJobPersistenceController(options: {
         }
 
         queueAssistantMessageUpdate(
-            (message) => ({
-                ...message,
-                content: latestContent,
-                ongoingToolCalls: latestToolCalls,
-                lifecycleState: 'running',
-                lifecycleError: undefined,
-                isComplete: false,
-                prompt: options.createPromptSnapshot({
-                    toolCalls: latestToolCalls,
-                }),
-            }),
+            (message) => {
+                const harnessProgressCard = createUserChatHarnessProgressCard(latestToolCalls);
+
+                return {
+                    ...message,
+                    content: latestContent,
+                    ongoingToolCalls: latestToolCalls,
+                    lifecycleState: 'running',
+                    lifecycleError: undefined,
+                    isComplete: false,
+                    progressCard: harnessProgressCard ?? message.progressCard,
+                    prompt: options.createPromptSnapshot({
+                        toolCalls: latestToolCalls,
+                    }),
+                };
+            },
             {
                 snapshotSignature,
             },

package/apps/agents-server/src/utils/userChat/createUserChatDetailPayload.ts

@@ -1,5 +1,6 @@
 import type { UserChatRecord } from './UserChatRecord';
 import { synchronizeLocalUserChatJobsForChat } from '../localChatRunner/synchronizeLocalUserChatJobs';
+import { hasPotentiallyPendingAssistantMessages } from './hasPotentiallyPendingAssistantMessages';
 import { createUserChatTimeoutActivity } from '../userChatTimeout/createUserChatTimeoutActivity';
 import { listUserChatTimeouts } from '../userChatTimeout/userChatTimeoutStore';
 import { createUserChatSummary } from './createUserChatSummary';
@@ -18,31 +19,45 @@ export async function createUserChatDetailPayload(chat: UserChatRecord): Promise
     activeTimeouts: Awaited<ReturnType<typeof listUserChatTimeouts>>;
 }> {
     let currentChat = chat;
-    const hasSynchronizedLocalJobs = await synchronizeLocalUserChatJobsForChat(currentChat);
-
-    if (hasSynchronizedLocalJobs) {
-        const refreshedChat = await getUserChat({
-            userId: currentChat.userId,
-            agentPermanentId: currentChat.agentPermanentId,
-            chatId: currentChat.id,
-        });
-
-        if (refreshedChat) {
-            currentChat = refreshedChat;
-        }
-    }
-
     let activeJobs = await listUserChatJobs({
         userId: currentChat.userId,
         agentPermanentId: currentChat.agentPermanentId,
         chatId: currentChat.id,
         onlyActive: true,
     });
+    const shouldInspectJobState =
+        activeJobs.length > 0 || hasPotentiallyPendingAssistantMessages(currentChat.messages);
 
-    const hasReconciledJobs = await reconcileUserChatActiveJobs({
-        chat: currentChat,
-        activeJobs,
-    });
+    if (shouldInspectJobState) {
+        const hasSynchronizedLocalJobs = await synchronizeLocalUserChatJobsForChat(currentChat);
+
+        if (hasSynchronizedLocalJobs) {
+            const refreshedChat = await getUserChat({
+                userId: currentChat.userId,
+                agentPermanentId: currentChat.agentPermanentId,
+                chatId: currentChat.id,
+            });
+
+            if (refreshedChat) {
+                currentChat = refreshedChat;
+            }
+
+            activeJobs = await listUserChatJobs({
+                userId: currentChat.userId,
+                agentPermanentId: currentChat.agentPermanentId,
+                chatId: currentChat.id,
+                onlyActive: true,
+            });
+        }
+    }
+
+    const hasReconciledJobs =
+        activeJobs.length > 0
+            ? await reconcileUserChatActiveJobs({
+                  chat: currentChat,
+                  activeJobs,
+              })
+            : false;
 
     if (hasReconciledJobs) {
         const refreshedChat = await getUserChat({