@promptbook/cli 0.112.0-112 → 0.112.0-114

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,30 @@ 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.
 
-    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.
 `);
 
 /**
- * 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/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({

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

@@ -0,0 +1,26 @@
+import type { ChatMessage } from '@promptbook-local/types';
+
+/**
+ * Returns `true` when the current transcript still suggests unfinished assistant work.
+ *
+ * This is intentionally message-based so readers can avoid heavier reconciliation work for
+ * settled chats while still inspecting threads that contain incomplete placeholders.
+ *
+ * @param messages - Current persisted chat transcript.
+ * @returns Whether the transcript still looks unfinished from the UI perspective.
+ * @private internal utility of `userChat`
+ */
+export function hasPotentiallyPendingAssistantMessages(messages: ReadonlyArray<ChatMessage>): boolean {
+    return messages.some((message) => {
+        const sender = String(message.sender || '').toUpperCase();
+        if (sender !== 'AGENT' && sender !== 'MODEL') {
+            return false;
+        }
+
+        return (
+            message.isComplete === false ||
+            message.lifecycleState === 'queued' ||
+            message.lifecycleState === 'running'
+        );
+    });
+}

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

@@ -44,7 +44,7 @@ type RunImmediateUserChatAnswerOptions = {
 };
 
 /**
- * Runs a fast local LLM answer into the incomplete assistant placeholder while the external runner is still working.
+ * Runs a fast local LLM pre-answer into the incomplete assistant placeholder while the external runner is still working.
  */
 export async function runImmediateUserChatAnswer(
     job: UserChatJobRecord,

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

@@ -1,28 +1,63 @@
 import { resolveUserChatWorkerInternalToken } from './resolveUserChatWorkerInternalToken';
+import { retryWithBackoff } from '../retryWithBackoff';
+
+/**
+ * Number of retries for transient transport failures while waking the durable chat worker.
+ */
+const USER_CHAT_WORKER_TRIGGER_FETCH_RETRIES = 2;
+
+/**
+ * Initial wait before retrying a failed worker wake-up request.
+ */
+const USER_CHAT_WORKER_TRIGGER_FETCH_INITIAL_DELAY_MS = 250;
+
+/**
+ * Maximum wait before retrying a failed worker wake-up request.
+ */
+const USER_CHAT_WORKER_TRIGGER_FETCH_MAX_DELAY_MS = 1_000;
+
+/**
+ * Multiplier used between worker wake-up retry waits.
+ */
+const USER_CHAT_WORKER_TRIGGER_FETCH_BACKOFF_FACTOR = 2;
+
+/**
+ * Randomized extra delay ratio for worker wake-up retry waits.
+ */
+const USER_CHAT_WORKER_TRIGGER_FETCH_JITTER_RATIO = 0.2;
 
 /**
  * Schedules one best-effort internal worker invocation for durable chat jobs.
  */
-export async function triggerUserChatJobWorker(options: {
-    origin: string;
-    preferredJobId?: string;
-}): Promise<void> {
+export async function triggerUserChatJobWorker(options: { origin: string; preferredJobId?: string }): Promise<void> {
     const workerUrl = new URL('/api/internal/user-chat-jobs/run', ensureTrailingSlashlessOrigin(options.origin));
-    const response = await fetch(workerUrl, {
-        method: 'POST',
-        cache: 'no-store',
-        headers: {
-            'Content-Type': 'application/json',
-            'x-user-chat-worker-token': resolveUserChatWorkerInternalToken(),
-        },
-        body: JSON.stringify(
-            options.preferredJobId
-                ? {
-                      preferredJobId: options.preferredJobId,
-                  }
-                : {},
-        ),
-    });
+    const response = (
+        await retryWithBackoff(
+            async () =>
+                await fetch(workerUrl, {
+                    method: 'POST',
+                    cache: 'no-store',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-user-chat-worker-token': resolveUserChatWorkerInternalToken(),
+                    },
+                    body: JSON.stringify(
+                        options.preferredJobId
+                            ? {
+                                  preferredJobId: options.preferredJobId,
+                              }
+                            : {},
+                    ),
+                }),
+            {
+                retries: USER_CHAT_WORKER_TRIGGER_FETCH_RETRIES,
+                initialDelayMs: USER_CHAT_WORKER_TRIGGER_FETCH_INITIAL_DELAY_MS,
+                maxDelayMs: USER_CHAT_WORKER_TRIGGER_FETCH_MAX_DELAY_MS,
+                backoffFactor: USER_CHAT_WORKER_TRIGGER_FETCH_BACKOFF_FACTOR,
+                jitterRatio: USER_CHAT_WORKER_TRIGGER_FETCH_JITTER_RATIO,
+            },
+        )
+    ).value;
 
     if (!response.ok && response.status !== 204) {
         throw new Error(`Failed to trigger user chat worker: ${response.status} ${response.statusText}`);

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

@@ -23,7 +23,7 @@ export const VPS_ENVIRONMENT_VARIABLE_KEYS = [
     'NEXT_PUBLIC_SITE_URL',
     'ADMIN_PASSWORD',
     'OPENAI_API_KEY',
-    'PTBK_AGENT',
+    'PTBK_HARNESS',
     'PTBK_MODEL',
     'PTBK_THINKING_LEVEL',
     'PORT',