@jskit-ai/assistant-runtime 0.1.142 → 0.1.144

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.1.142",
+  "version": "0.1.144",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -11,15 +11,15 @@
     "./server/actionIds": "./src/server/actionIds.js"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.147",
-    "@jskit-ai/database-runtime": "0.1.171",
+    "@jskit-ai/assistant-core": "0.1.149",
+    "@jskit-ai/database-runtime": "0.1.173",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.1.169",
-    "@jskit-ai/http-web": "0.1.16",
-    "@jskit-ai/kernel": "0.1.171",
-    "@jskit-ai/shell-web": "0.1.175",
+    "@jskit-ai/http-runtime": "0.1.171",
+    "@jskit-ai/http-web": "0.1.18",
+    "@jskit-ai/kernel": "0.1.173",
+    "@jskit-ai/shell-web": "0.1.177",
     "@tanstack/vue-query": "^5.90.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0"

package/src/client/composables/useAssistantRuntime.js

@@ -5,14 +5,12 @@ import { normalizeObject, normalizeRecordId, normalizeText } from "@jskit-ai/ker
 import { buildAssistantApiPath } from "@jskit-ai/assistant-core/shared";
 import {
   ASSISTANT_STREAM_EVENT_TYPES,
-  MAX_HISTORY_MESSAGES,
   MAX_INPUT_CHARS,
   assistantConversationMessagesQueryKey,
   assistantConversationsListQueryKey,
   assistantScopeQueryKey,
   normalizeAssistantStreamEventType,
   normalizeConversationStatus as normalizeAssistantConversationStatus,
-  parseJsonObject,
   toPositiveInteger
 } from "@jskit-ai/assistant-core/shared";
 import {
@@ -23,6 +21,13 @@ import { useShellWebErrorRuntime } from "@jskit-ai/shell-web/client/error";
 import { usePagedCollection } from "@jskit-ai/http-web/client/composables/usePagedCollection";
 import { useSurfaceRouteContext } from "@jskit-ai/shell-web/client/navigation/useSurfaceRouteContext";
 import { resolveAssistantSurfaceConfig } from "../../shared/assistantSurfaces.js";
+import {
+  buildHistory,
+  buildId,
+  interruptPendingToolEvents,
+  mapTranscriptEntriesToAssistantState,
+  normalizeToolName
+} from "../support/assistantRuntimeState.js";
 import { insertTextAtSelection } from "../support/composerInputSupport.js";
 import { useWorkspaceWebScopeSupport } from "../support/workspaceScopeSupport.js";
 
@@ -78,18 +83,6 @@ function writeStoredActiveConversationId(scope = {}, conversationId) {
   }
 }
 
-function buildId(prefix = "id") {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return `${prefix}_${crypto.randomUUID()}`;
-  }
-
-  return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-}
-
-function normalizeToolName(value) {
-  return normalizeText(value) || "tool";
-}
-
 function normalizeConversationStatus(value) {
   return normalizeAssistantConversationStatus(value, {
     fallback: "unknown"
@@ -110,103 +103,6 @@ function formatConversationStartedAt(value) {
   return date.toLocaleString();
 }
 
-function parseToolResultPayload(value) {
-  return parseJsonObject(value);
-}
-
-function buildHistory(messages) {
-  const normalizedHistory = (Array.isArray(messages) ? messages : [])
-    .filter((message) => {
-      if (!message || typeof message !== "object") {
-        return false;
-      }
-      if (message.kind !== "chat") {
-        return false;
-      }
-      if (message.role !== "user" && message.role !== "assistant") {
-        return false;
-      }
-      if (normalizeText(message.status).toLowerCase() !== "done") {
-        return false;
-      }
-      return Boolean(normalizeText(message.text));
-    })
-    .map((message) => ({
-      role: message.role,
-      content: String(message.text || "").slice(0, MAX_INPUT_CHARS)
-    }));
-
-  return normalizedHistory.slice(-MAX_HISTORY_MESSAGES);
-}
-
-function mapTranscriptEntriesToAssistantState(entries) {
-  const sourceEntries = Array.isArray(entries) ? entries : [];
-  const messages = [];
-  const toolEventsById = new Map();
-
-  function ensureToolEvent(toolCallId, toolName) {
-    const key = normalizeText(toolCallId) || buildId("tool_call");
-    if (toolEventsById.has(key)) {
-      return toolEventsById.get(key);
-    }
-
-    const next = {
-      id: key,
-      name: normalizeToolName(toolName),
-      arguments: "",
-      status: "pending",
-      result: null,
-      error: null
-    };
-    toolEventsById.set(key, next);
-    return next;
-  }
-
-  for (const entry of sourceEntries) {
-    const role = normalizeText(entry?.role).toLowerCase();
-    const kind = normalizeText(entry?.kind).toLowerCase();
-    const metadata = normalizeObject(entry?.metadata);
-    const transcriptId = normalizeRecordId(entry?.id, { fallback: null });
-    const messageId = transcriptId ? `transcript_${transcriptId}` : buildId("transcript");
-
-    if (kind === "chat" && (role === "user" || role === "assistant")) {
-      messages.push({
-        id: messageId,
-        role,
-        kind: "chat",
-        text: entry?.contentText == null ? "" : String(entry.contentText),
-        status: "done"
-      });
-      continue;
-    }
-
-    if (kind === "tool_call") {
-      const toolCallId = normalizeText(metadata.toolCallId) || `tool_call_${messageId}`;
-      const toolName = normalizeToolName(metadata.tool);
-      const toolEvent = ensureToolEvent(toolCallId, toolName);
-      toolEvent.arguments = String(entry?.contentText || "");
-      toolEvent.status = "pending";
-      continue;
-    }
-
-    if (kind === "tool_result") {
-      const parsedResult = parseToolResultPayload(entry?.contentText);
-      const toolCallId = normalizeText(metadata.toolCallId || parsedResult.toolCallId) || `tool_result_${messageId}`;
-      const toolName = normalizeToolName(metadata.tool || parsedResult.tool);
-      const toolEvent = ensureToolEvent(toolCallId, toolName);
-      const failed = parsedResult.ok === false || metadata.ok === false;
-      toolEvent.status = failed ? "failed" : "done";
-      toolEvent.result = failed ? null : parsedResult.result;
-      toolEvent.error = failed ? parsedResult.error || metadata.error || null : null;
-    }
-  }
-
-  return {
-    messages,
-    pendingToolEvents: [...toolEventsById.values()]
-  };
-}
-
 function resolveRuntimePolicy() {
   const appConfig = getClientAppConfig();
   const assistantConfig = normalizeObject(appConfig?.assistant);
@@ -724,6 +620,7 @@ function useAssistantRuntime({ api = null, surfaceId = "" } = {}) {
       }
     } finally {
       clearTimeout(streamTimeout);
+      pendingToolEvents.value = interruptPendingToolEvents(pendingToolEvents.value);
       abortController.value = null;
       isStreaming.value = false;
       await invalidateConversationScope();

package/src/client/support/assistantRuntimeState.js

@@ -0,0 +1,140 @@
+import { normalizeObject, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import {
+  MAX_HISTORY_MESSAGES,
+  MAX_INPUT_CHARS,
+  parseJsonObject
+} from "@jskit-ai/assistant-core/shared";
+import { isAssistantProgressOnlyText } from "../../shared/assistantResponseText.js";
+
+function buildId(prefix = "id") {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return `${prefix}_${crypto.randomUUID()}`;
+  }
+
+  return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function normalizeToolName(value) {
+  return normalizeText(value) || "tool";
+}
+
+function buildHistory(messages) {
+  const normalizedHistory = (Array.isArray(messages) ? messages : [])
+    .filter((message) => {
+      if (!message || typeof message !== "object") {
+        return false;
+      }
+      if (message.kind !== "chat") {
+        return false;
+      }
+      if (message.role !== "user" && message.role !== "assistant") {
+        return false;
+      }
+      if (normalizeText(message.status).toLowerCase() !== "done") {
+        return false;
+      }
+      const text = normalizeText(message.text);
+      if (!text) {
+        return false;
+      }
+      return message.role !== "assistant" || !isAssistantProgressOnlyText(text);
+    })
+    .map((message) => ({
+      role: message.role,
+      content: String(message.text || "").slice(0, MAX_INPUT_CHARS)
+    }));
+
+  return normalizedHistory.slice(-MAX_HISTORY_MESSAGES);
+}
+
+function interruptPendingToolEvents(toolEvents) {
+  return (Array.isArray(toolEvents) ? toolEvents : []).map((toolEvent) => {
+    if (normalizeText(toolEvent?.status).toLowerCase() !== "pending") {
+      return toolEvent;
+    }
+
+    return {
+      ...toolEvent,
+      status: "interrupted"
+    };
+  });
+}
+
+function mapTranscriptEntriesToAssistantState(entries) {
+  const sourceEntries = Array.isArray(entries) ? entries : [];
+  const messages = [];
+  const toolEventsById = new Map();
+
+  function ensureToolEvent(toolCallId, toolName) {
+    const key = normalizeText(toolCallId) || buildId("tool_call");
+    if (toolEventsById.has(key)) {
+      return toolEventsById.get(key);
+    }
+
+    const next = {
+      id: key,
+      name: normalizeToolName(toolName),
+      arguments: "",
+      status: "pending",
+      result: null,
+      error: null
+    };
+    toolEventsById.set(key, next);
+    return next;
+  }
+
+  for (const entry of sourceEntries) {
+    const role = normalizeText(entry?.role).toLowerCase();
+    const kind = normalizeText(entry?.kind).toLowerCase();
+    const metadata = normalizeObject(entry?.metadata);
+    const transcriptId = normalizeRecordId(entry?.id, { fallback: null });
+    const messageId = transcriptId ? `transcript_${transcriptId}` : buildId("transcript");
+
+    if (kind === "chat" && (role === "user" || role === "assistant")) {
+      const text = entry?.contentText == null ? "" : String(entry.contentText);
+      if (role === "assistant" && isAssistantProgressOnlyText(text)) {
+        continue;
+      }
+
+      messages.push({
+        id: messageId,
+        role,
+        kind: "chat",
+        text,
+        status: "done"
+      });
+      continue;
+    }
+
+    if (kind === "tool_call") {
+      const toolCallId = normalizeText(metadata.toolCallId) || `tool_call_${messageId}`;
+      const toolEvent = ensureToolEvent(toolCallId, metadata.tool);
+      toolEvent.arguments = String(entry?.contentText || "");
+      toolEvent.status = "pending";
+      continue;
+    }
+
+    if (kind === "tool_result") {
+      const parsedResult = parseJsonObject(entry?.contentText);
+      const toolCallId = normalizeText(metadata.toolCallId || parsedResult.toolCallId) || `tool_result_${messageId}`;
+      const toolEvent = ensureToolEvent(toolCallId, metadata.tool || parsedResult.tool);
+      const failed = parsedResult.ok === false || metadata.ok === false;
+      toolEvent.status = failed ? "failed" : "done";
+      toolEvent.result = failed ? null : parsedResult.result;
+      toolEvent.error = failed ? parsedResult.error || metadata.error || null : null;
+    }
+  }
+
+  return {
+    messages,
+    pendingToolEvents: interruptPendingToolEvents([...toolEventsById.values()])
+  };
+}
+
+export {
+  buildHistory,
+  buildId,
+  interruptPendingToolEvents,
+  mapTranscriptEntriesToAssistantState,
+  normalizeToolName
+};

package/src/server/services/chatService.js

@@ -5,10 +5,15 @@ import {
   ASSISTANT_STREAM_EVENT_TYPES
 } from "@jskit-ai/assistant-core/shared";
 import { resolveAssistantSurfaceConfig } from "../../shared/assistantSurfaces.js";
+import { isAssistantProgressOnlyText } from "../../shared/assistantResponseText.js";
 
 const MAX_HISTORY_MESSAGES = 20;
 const MAX_INPUT_CHARS = 8000;
-const MAX_TOOL_ROUNDS = 4;
+const MAX_TOOL_ROUNDS = 16;
+const MAX_RECOVERY_PASSES = 3;
+const MAX_TOOL_RESULT_FALLBACK_CHARS = 4000;
+const CLOCK_INSTRUCTION = "For current or relative date and time questions, first use any available authoritative workspace clock action; never infer the current date or time from model knowledge.";
+const COMPLETION_INSTRUCTION = "Do not narrate future work or describe what you are about to do. Either call the required available tool now or provide the completed final answer.";
 
 function normalizeConversationId(value) {
   return normalizeRecordId(value, { fallback: null });
@@ -26,7 +31,7 @@ function normalizeHistory(history = []) {
       }
 
       const content = normalizeText(item.content).slice(0, MAX_INPUT_CHARS);
-      if (!content) {
+      if (!content || (role === "assistant" && isAssistantProgressOnlyText(content))) {
         return null;
       }
 
@@ -152,6 +157,7 @@ function buildSystemPrompt({ targetSurfaceId = "", toolDescriptors = [], workspa
     "Use tools when they are necessary and only when available.",
     "Do not mention tools that are not available.",
     "When answering schema questions, rely only on tool contracts and tool results.",
+    CLOCK_INSTRUCTION,
     workspaceLine,
     toolSummary,
     toolContracts
@@ -183,22 +189,17 @@ function buildRecoveryPrompt({ reason = "", toolFailures = [], toolSuccesses = [
   const failureSuffix = failureSummary ? ` Recent tool failures: ${failureSummary}.` : "";
   const successSuffix = successSummary ? ` Successful tools: ${successSummary}.` : "";
   if (normalizedReason === "tool_failure") {
-    return `One or more tool calls may fail. Continue with available successful results. Do not output function-call markup. Do not mention failed operations unless explicitly asked.${failureSuffix}${successSuffix}`;
+    return `One or more tool calls may fail. Continue with available successful results. Do not output function-call markup. Do not mention failed operations unless explicitly asked. ${COMPLETION_INSTRUCTION}${failureSuffix}${successSuffix}`;
   }
 
-  return `Tool-call rounds were exhausted. Provide the best direct answer with available context and successful results only.${failureSuffix}${successSuffix}`;
+  return `Tool-call rounds were exhausted. Provide the best direct answer with available context and successful results only. ${COMPLETION_INSTRUCTION}${failureSuffix}${successSuffix}`;
 }
 
-function buildRecoveryFallbackAnswer({ reason = "", toolFailures = [], toolSuccesses = [] } = {}) {
-  const normalizedReason = normalizeText(reason).toLowerCase();
-  if (normalizedReason === "tool_failure") {
-    return buildToolOutcomeFallbackAnswer({
-      toolFailures,
-      toolSuccesses
-    });
-  }
-
-  return "I reached the tool-call limit for this request. Please narrow the request and I will continue.";
+function buildRecoveryFallbackAnswer({ toolFailures = [], toolSuccesses = [] } = {}) {
+  return buildToolOutcomeFallbackAnswer({
+    toolFailures,
+    toolSuccesses
+  });
 }
 
 function toSafeToolResultText(value) {
@@ -217,26 +218,19 @@ function toSafeToolResultText(value) {
 }
 
 function buildToolOutcomeFallbackAnswer({ toolFailures = [], toolSuccesses = [] } = {}) {
-  const successNames = [...new Set(
-    (Array.isArray(toolSuccesses) ? toolSuccesses : [])
-      .map((entry) => normalizeText(entry?.name))
-      .filter(Boolean)
-  )];
+  const successfulResults = (Array.isArray(toolSuccesses) ? toolSuccesses : [])
+    .filter((entry) => normalizeText(entry?.name));
   const hasFailures = Array.isArray(toolFailures) && toolFailures.length > 0;
 
-  if (successNames.length > 0) {
-    const summaryLines = (Array.isArray(toolSuccesses) ? toolSuccesses : [])
-      .filter((entry) => normalizeText(entry?.name))
-      .map((entry) => {
-        const name = normalizeText(entry.name);
-        const payload = toSafeToolResultText(entry.result);
-        return `- ${name}:\n\`\`\`json\n${payload}\n\`\`\``;
-      });
+  if (successfulResults.length > 0) {
+    const latestSuccess = successfulResults.at(-1);
+    const answer = `Latest successful result from ${normalizeText(latestSuccess.name)}:\n${toSafeToolResultText(latestSuccess.result)}`;
+    if (answer.length <= MAX_TOOL_RESULT_FALLBACK_CHARS) {
+      return answer;
+    }
 
-    return [
-      "I used the available successful results:",
-      ...summaryLines
-    ].join("\n");
+    const suffix = "\n…[truncated]";
+    return `${answer.slice(0, MAX_TOOL_RESULT_FALLBACK_CHARS - suffix.length)}${suffix}`;
   }
 
   if (hasFailures) {
@@ -255,7 +249,8 @@ function sanitizeAssistantMessageText(value) {
   const blockPatterns = [
     /<[^>\n]*function_calls[^>\n]*>[\s\S]*?<\/[^>\n]*function_calls>/gi,
     /<[^>\n]*tool_calls?[^>\n]*>[\s\S]*?<\/[^>\n]*tool_calls?[^>\n]*>/gi,
-    /<[^>\n]*invoke\b[^>\n]*>[\s\S]*?<\/[^>\n]*invoke>/gi
+    /<[^>\n]*invoke\b[^>\n]*>[\s\S]*?<\/[^>\n]*invoke>/gi,
+    /<(?:analysis|reasoning|think)>[\s\S]*?<\/(?:analysis|reasoning|think)>/gi
   ];
   for (const pattern of blockPatterns) {
     source = source.replace(pattern, " ");
@@ -279,10 +274,10 @@ function sanitizeAssistantMessageText(value) {
     .join("\n");
 }
 
-function buildAssistantToolCallMessage({ assistantText = "", toolCalls = [] } = {}) {
+function buildAssistantToolCallMessage(toolCalls = []) {
   return {
     role: "assistant",
-    content: assistantText || "",
+    content: "",
     tool_calls: toolCalls.map((toolCall) => ({
       id: toolCall.id,
       type: "function",
@@ -336,96 +331,8 @@ function parseDsmlToolCallsFromText(value = "") {
   return calls;
 }
 
-function createDsmlDeltaSanitizer() {
-  let inTag = false;
-  let tagBuffer = "";
-  let suppressedDepth = 0;
-
-  function resolveTagType(rawTag = "") {
-    const normalizedTag = String(rawTag || "").toLowerCase();
-    if (normalizedTag.includes("function_calls")) {
-      return "function_calls";
-    }
-    if (normalizedTag.includes("tool_calls")) {
-      return "tool_calls";
-    }
-    if (normalizedTag.includes("invoke")) {
-      return "invoke";
-    }
-    return "";
-  }
-
-  function processTag(rawTag = "") {
-    const source = String(rawTag || "");
-    const inner = source.slice(1, -1).trim();
-    const isClosing = inner.startsWith("/");
-    const isSelfClosing = inner.endsWith("/");
-    const tagType = resolveTagType(inner);
-
-    if (suppressedDepth > 0) {
-      if (tagType && isClosing) {
-        suppressedDepth = Math.max(0, suppressedDepth - 1);
-      } else if (tagType && !isClosing && !isSelfClosing) {
-        suppressedDepth += 1;
-      }
-      return "";
-    }
-
-    if (!tagType) {
-      return source;
-    }
-
-    if (!isClosing && !isSelfClosing) {
-      suppressedDepth = 1;
-    }
-    return "";
-  }
-
-  function process(delta = "") {
-    const source = String(delta || "");
-    if (!source) {
-      return "";
-    }
-
-    let output = "";
-    for (const char of source) {
-      if (inTag) {
-        tagBuffer += char;
-        if (char === ">") {
-          inTag = false;
-          output += processTag(tagBuffer);
-          tagBuffer = "";
-        }
-        continue;
-      }
-
-      if (char === "<") {
-        inTag = true;
-        tagBuffer = "<";
-        continue;
-      }
-
-      if (suppressedDepth < 1) {
-        output += char;
-      }
-    }
-
-    return output;
-  }
-
-  function flush() {
-    return "";
-  }
-
-  return Object.freeze({
-    process,
-    flush
-  });
-}
-
-async function consumeCompletionStream({ stream, streamWriter, emitDeltas = true, deltaSanitizer = null } = {}) {
+async function consumeCompletionStream(stream) {
   let assistantText = "";
-  let streamedAssistantText = "";
   const toolCallsByIndex = new Map();
 
   for await (const chunk of stream) {
@@ -435,19 +342,6 @@ async function consumeCompletionStream({ stream, streamWriter, emitDeltas = true
     const textDelta = extractTextDelta(delta.content);
     if (textDelta) {
       assistantText += textDelta;
-      if (emitDeltas) {
-        const safeDelta =
-          deltaSanitizer && typeof deltaSanitizer.process === "function"
-            ? String(deltaSanitizer.process(textDelta) || "")
-            : textDelta;
-        if (safeDelta) {
-          streamedAssistantText += safeDelta;
-          streamWriter.sendAssistantDelta({
-            type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_DELTA,
-            delta: safeDelta
-          });
-        }
-      }
     }
 
     const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
@@ -489,47 +383,12 @@ async function consumeCompletionStream({ stream, streamWriter, emitDeltas = true
     }
   }
 
-  if (emitDeltas && deltaSanitizer && typeof deltaSanitizer.flush === "function") {
-    const trailing = String(deltaSanitizer.flush() || "");
-    if (trailing) {
-      streamedAssistantText += trailing;
-      streamWriter.sendAssistantDelta({
-        type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_DELTA,
-        delta: trailing
-      });
-    }
-  }
-
   return {
     assistantText,
-    streamedAssistantText,
     toolCalls
   };
 }
 
-function mergeAssistantMessageText(streamedText = "", completionText = "") {
-  const streamed = normalizeText(sanitizeAssistantMessageText(streamedText));
-  const completion = normalizeText(sanitizeAssistantMessageText(completionText));
-
-  if (!streamed) {
-    return completion;
-  }
-  if (!completion) {
-    return streamed;
-  }
-  if (streamed === completion) {
-    return streamed;
-  }
-  if (completion.startsWith(streamed) || completion.includes(streamed)) {
-    return completion;
-  }
-  if (streamed.startsWith(completion) || streamed.includes(completion)) {
-    return streamed;
-  }
-
-  return `${streamed}\n${completion}`;
-}
-
 function requireAssistantSurface(appConfig = {}, targetSurfaceId = "") {
   const assistantSurface = resolveAssistantSurfaceConfig(appConfig, targetSurfaceId);
   if (assistantSurface) {
@@ -664,10 +523,9 @@ function createChatService({
         content: source.input
       }
     ];
-    let streamedAssistantText = "";
 
     async function completeWithAssistantMessage(assistantMessageText, { metadata = {} } = {}) {
-      const normalizedAssistantMessageText = mergeAssistantMessageText(streamedAssistantText, assistantMessageText);
+      const normalizedAssistantMessageText = normalizeText(sanitizeAssistantMessageText(assistantMessageText));
       if (!normalizedAssistantMessageText) {
         throw new AppError(502, "Assistant returned no output.");
       }
@@ -820,7 +678,6 @@ function createChatService({
     }
 
     async function recoverWithoutTools({ reason = "", toolFailures = [], toolSuccesses = [] } = {}) {
-      const MAX_RECOVERY_PASSES = 3;
       for (let pass = 0; pass < MAX_RECOVERY_PASSES; pass += 1) {
         const recoveryMessages = [
           ...messages,
@@ -839,31 +696,15 @@ function createChatService({
           tools: [],
           signal: options.abortSignal
         });
-        const completion = await consumeCompletionStream({
-          stream: completionStream,
-          streamWriter,
-          emitDeltas: true,
-          deltaSanitizer: createDsmlDeltaSanitizer()
-        });
-        streamedAssistantText += String(completion.streamedAssistantText || "");
+        const completion = await consumeCompletionStream(completionStream);
 
         const recoveryToolCalls = completion.toolCalls.filter((entry) => entry.name);
         if (recoveryToolCalls.length > 0) {
-          messages.push(
-            buildAssistantToolCallMessage({
-              assistantText: completion.assistantText,
-              toolCalls: recoveryToolCalls
-            })
-          );
-          await executeToolCalls(recoveryToolCalls, {
-            toolFailures,
-            toolSuccesses
-          });
           continue;
         }
 
         const assistantMessageText = normalizeText(sanitizeAssistantMessageText(completion.assistantText));
-        if (assistantMessageText) {
+        if (assistantMessageText && !isAssistantProgressOnlyText(assistantMessageText)) {
           return completeWithAssistantMessage(assistantMessageText, {
             metadata: {
               recoveryReason: reason || "unknown",
@@ -914,18 +755,12 @@ function createChatService({
           signal: options.abortSignal
         });
 
-        const completion = await consumeCompletionStream({
-          stream: completionStream,
-          streamWriter,
-          emitDeltas: true,
-          deltaSanitizer: createDsmlDeltaSanitizer()
-        });
-        streamedAssistantText += String(completion.streamedAssistantText || "");
+        const completion = await consumeCompletionStream(completionStream);
 
         const toolCalls = completion.toolCalls.filter((entry) => entry.name);
         if (toolCalls.length < 1) {
           const finalMessageText = normalizeText(sanitizeAssistantMessageText(completion.assistantText));
-          if (finalMessageText) {
+          if (finalMessageText && !isAssistantProgressOnlyText(finalMessageText)) {
             return completeWithAssistantMessage(finalMessageText, {
               metadata: toolFailures.length > 0
                 ? {
@@ -936,23 +771,14 @@ function createChatService({
             });
           }
 
-          if (toolFailures.length > 0) {
-            return recoverWithoutTools({
-              reason: "tool_failure",
-              toolFailures,
-              toolSuccesses
-            });
-          }
-
-          return completeWithAssistantMessage(completion.assistantText);
+          messages.push({
+            role: "system",
+            content: COMPLETION_INSTRUCTION
+          });
+          continue;
         }
 
-        messages.push(
-          buildAssistantToolCallMessage({
-            assistantText: completion.assistantText,
-            toolCalls
-          })
-        );
+        messages.push(buildAssistantToolCallMessage(toolCalls));
 
         const roundFailures = await executeToolCalls(toolCalls, {
           toolFailures,

package/src/shared/assistantResponseText.js

@@ -0,0 +1,29 @@
+const MAX_PROGRESS_ONLY_TEXT_CHARS = 600;
+
+const PROGRESS_SENTENCE_PATTERNS = Object.freeze([
+  /^(?:let me|i(?:'|’)ll|i will|i(?:'|’)m going to|i am going to)\s+(?:(?:first|now|quickly)\s+)*(?:analy[sz]e|call|check|confirm|do|execute|fetch|find|inspect|investigate|load|look up|open|prepare|query|read|retrieve|review|run|search|summarize|test|try|use|verify)\b/iu,
+  /^(?:analy[sz]ing|calling|checking|confirming|executing|fetching|finding|inspecting|investigating|loading|looking up|opening|preparing|querying|reading|retrieving|reviewing|running|searching|summarizing|testing|trying|using|verifying)\b/iu,
+  /^(?:one moment|please wait)\b/iu
+]);
+
+function isAssistantProgressOnlyText(value) {
+  const text = String(value || "")
+    .replace(/\s+/gu, " ")
+    .trim()
+    .replace(/^(?:okay|sure)[,;:!\s—-]+/iu, "");
+
+  if (!text || text.length > MAX_PROGRESS_ONLY_TEXT_CHARS) {
+    return false;
+  }
+
+  const sentences = text
+    .split(/(?<=[.!?…])\s+/u)
+    .map((sentence) => sentence.trim())
+    .filter(Boolean);
+
+  return sentences.length > 0 && sentences.every((sentence) =>
+    PROGRESS_SENTENCE_PATTERNS.some((pattern) => pattern.test(sentence))
+  );
+}
+
+export { isAssistantProgressOnlyText };

package/test/assistantRuntimeState.test.js

@@ -0,0 +1,134 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  buildHistory,
+  interruptPendingToolEvents,
+  mapTranscriptEntriesToAssistantState
+} from "../src/client/support/assistantRuntimeState.js";
+
+test("restored progress narration is neither rendered nor replayed", () => {
+  const restored = mapTranscriptEntriesToAssistantState([
+    {
+      id: "1",
+      role: "user",
+      kind: "chat",
+      contentText: "Find the booking."
+    },
+    {
+      id: "2",
+      role: "assistant",
+      kind: "chat",
+      contentText: "Let me query the bookings."
+    },
+    {
+      id: "3",
+      role: "assistant",
+      kind: "chat",
+      contentText: "The booking is confirmed."
+    },
+    {
+      id: "4",
+      role: "assistant",
+      kind: "chat",
+      contentText: "Let me check. The second booking is also confirmed."
+    }
+  ]);
+
+  assert.deepEqual(
+    restored.messages.map((message) => message.text),
+    [
+      "Find the booking.",
+      "The booking is confirmed.",
+      "Let me check. The second booking is also confirmed."
+    ]
+  );
+  assert.deepEqual(buildHistory(restored.messages), [
+    {
+      role: "user",
+      content: "Find the booking."
+    },
+    {
+      role: "assistant",
+      content: "The booking is confirmed."
+    },
+    {
+      role: "assistant",
+      content: "Let me check. The second booking is also confirmed."
+    }
+  ]);
+});
+
+test("restored orphaned tool calls are marked interrupted", () => {
+  const restored = mapTranscriptEntriesToAssistantState([
+    {
+      id: "1",
+      role: "assistant",
+      kind: "tool_call",
+      contentText: "{}",
+      metadata: {
+        toolCallId: "orphaned",
+        tool: "action_search"
+      }
+    },
+    {
+      id: "2",
+      role: "assistant",
+      kind: "tool_call",
+      contentText: "{}",
+      metadata: {
+        toolCallId: "completed",
+        tool: "action_execute"
+      }
+    },
+    {
+      id: "3",
+      role: "assistant",
+      kind: "tool_result",
+      contentText: JSON.stringify({
+        ok: true,
+        result: {
+          id: "41"
+        }
+      }),
+      metadata: {
+        toolCallId: "completed",
+        tool: "action_execute",
+        ok: true
+      }
+    }
+  ]);
+
+  assert.deepEqual(
+    restored.pendingToolEvents.map((event) => ({ id: event.id, status: event.status })),
+    [
+      { id: "orphaned", status: "interrupted" },
+      { id: "completed", status: "done" }
+    ]
+  );
+});
+
+test("live stream cleanup interrupts only tool events that remain pending", () => {
+  const finalized = interruptPendingToolEvents([
+    {
+      id: "pending",
+      status: "pending"
+    },
+    {
+      id: "done",
+      status: "done"
+    },
+    {
+      id: "failed",
+      status: "failed"
+    }
+  ]);
+
+  assert.deepEqual(
+    finalized.map((event) => ({ id: event.id, status: event.status })),
+    [
+      { id: "pending", status: "interrupted" },
+      { id: "done", status: "done" },
+      { id: "failed", status: "failed" }
+    ]
+  );
+});

package/test/chatServiceLifecycle.test.js

@@ -0,0 +1,300 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createChatService } from "../src/server/services/chatService.js";
+
+const APP_CONFIG = Object.freeze({
+  surfaceDefinitions: {
+    assistant: {
+      id: "assistant",
+      enabled: true,
+      requiresWorkspace: false,
+      accessPolicyId: "public"
+    }
+  },
+  assistantSurfaces: {
+    assistant: {
+      settingsSurfaceId: "assistant",
+      configScope: "global"
+    }
+  }
+});
+
+function textCompletion(text) {
+  return { text };
+}
+
+function toolCompletion(name, sequence, { text = "" } = {}) {
+  return {
+    text,
+    toolCall: {
+      id: `tool_call_${sequence}`,
+      name,
+      arguments: JSON.stringify({ sequence })
+    }
+  };
+}
+
+async function* completionStream(completion = {}) {
+  if (completion.text) {
+    yield {
+      choices: [
+        {
+          delta: {
+            content: completion.text
+          }
+        }
+      ]
+    };
+  }
+
+  if (completion.toolCall) {
+    yield {
+      choices: [
+        {
+          delta: {
+            tool_calls: [
+              {
+                index: 0,
+                id: completion.toolCall.id,
+                function: {
+                  name: completion.toolCall.name,
+                  arguments: completion.toolCall.arguments
+                }
+              }
+            ]
+          }
+        }
+      ]
+    };
+  }
+}
+
+function createHarness(completions, { executeToolCall = null } = {}) {
+  const pendingCompletions = [...completions];
+  const completionRequests = [];
+  const transcriptMessages = [];
+  const completedConversations = [];
+  const executedTools = [];
+  const streamEvents = [];
+  const tools = ["action_search", "action_contract", "action_execute"].map((name) => ({
+    name,
+    parameters: {
+      type: "object"
+    },
+    outputSchema: {
+      type: "object"
+    }
+  }));
+
+  const chatService = createChatService({
+    aiClientFactory: {
+      resolveClient() {
+        return {
+          enabled: true,
+          provider: "test",
+          defaultModel: "test-model",
+          async createChatCompletionStream(request) {
+            completionRequests.push({
+              messages: structuredClone(request.messages),
+              tools: structuredClone(request.tools)
+            });
+            const completion = pendingCompletions.shift();
+            assert.ok(completion, "Expected a queued assistant completion.");
+            return completionStream(completion);
+          }
+        };
+      }
+    },
+    transcriptService: {
+      async createConversationForTurn() {
+        return {
+          conversation: {
+            id: "conversation_1"
+          }
+        };
+      },
+      async appendMessage(_surface, _conversationId, message) {
+        transcriptMessages.push(structuredClone(message));
+      },
+      async completeConversation(_surface, _conversationId, completion) {
+        completedConversations.push(structuredClone(completion));
+      }
+    },
+    serviceToolCatalog: {
+      resolveToolSet() {
+        return { tools };
+      },
+      toOpenAiToolSchema(tool) {
+        return {
+          type: "function",
+          function: {
+            name: tool.name,
+            parameters: tool.parameters
+          }
+        };
+      },
+      async executeToolCall(request) {
+        executedTools.push(structuredClone(request));
+        if (typeof executeToolCall === "function") {
+          return executeToolCall(request, executedTools.length);
+        }
+        return {
+          ok: true,
+          result: {
+            sequence: executedTools.length,
+            tool: request.toolName
+          }
+        };
+      }
+    },
+    assistantConfigService: {
+      async resolveSystemPrompt() {
+        return "";
+      }
+    },
+    appConfig: APP_CONFIG
+  });
+
+  const streamWriter = {};
+  for (const method of [
+    "sendMeta",
+    "sendAssistantDelta",
+    "sendAssistantMessage",
+    "sendToolCall",
+    "sendToolResult",
+    "sendError",
+    "sendDone"
+  ]) {
+    streamWriter[method] = (payload) => {
+      streamEvents.push({ method, payload: structuredClone(payload) });
+    };
+  }
+
+  async function run(input = "Help me") {
+    return chatService.streamChat(
+      {
+        targetSurfaceId: "assistant",
+        messageId: "message_1",
+        input,
+        history: []
+      },
+      {
+        context: {
+          actor: {
+            id: "user_1"
+          }
+        },
+        streamWriter
+      }
+    );
+  }
+
+  return {
+    completedConversations,
+    completionRequests,
+    executedTools,
+    run,
+    streamEvents,
+    transcriptMessages
+  };
+}
+
+function assistantMessages(events) {
+  return events
+    .filter((event) => event.method === "sendAssistantMessage")
+    .map((event) => event.payload.text);
+}
+
+test("progress-only output is retried silently and current-time prompts require a workspace clock", async () => {
+  const harness = createHarness([
+    textCompletion("Let me query the current time."),
+    textCompletion("<think>This must remain private.</think>\nIt is Tuesday in the workspace timezone.")
+  ]);
+
+  const result = await harness.run("What day is it today?");
+
+  assert.equal(result.status, "completed");
+  assert.deepEqual(assistantMessages(harness.streamEvents), ["It is Tuesday in the workspace timezone."]);
+  assert.equal(harness.streamEvents.some((event) => event.method === "sendAssistantDelta"), false);
+  assert.match(
+    harness.completionRequests[0].messages[0].content,
+    /first use any available authoritative workspace clock action/u
+  );
+  assert.equal(
+    harness.completionRequests[1].messages.some((message) => message.content === "Let me query the current time."),
+    false
+  );
+  assert.equal(
+    harness.completionRequests[1].messages.some((message) => /Either call the required available tool now/u.test(message.content)),
+    true
+  );
+  assert.deepEqual(
+    harness.transcriptMessages
+      .filter((message) => message.kind === "chat")
+      .map((message) => message.contentText),
+    ["What day is it today?", "It is Tuesday in the workspace timezone."]
+  );
+});
+
+test("native search, contract, and execution workflows can exceed four silent tool rounds", async () => {
+  const harness = createHarness([
+    toolCompletion("action_search", 1, { text: "I'll search first." }),
+    toolCompletion("action_contract", 2, { text: "Let me inspect that contract." }),
+    toolCompletion("action_execute", 3, { text: "I'll execute it now." }),
+    toolCompletion("action_contract", 4),
+    toolCompletion("action_execute", 5),
+    textCompletion("The requested operation completed successfully.")
+  ]);
+
+  await harness.run();
+
+  assert.deepEqual(
+    harness.executedTools.map((request) => request.toolName),
+    ["action_search", "action_contract", "action_execute", "action_contract", "action_execute"]
+  );
+  assert.deepEqual(assistantMessages(harness.streamEvents), ["The requested operation completed successfully."]);
+  assert.equal(harness.streamEvents.some((event) => event.method === "sendAssistantDelta"), false);
+  const assistantToolMessages = harness.completionRequests
+    .flatMap((request) => request.messages)
+    .filter((message) => Array.isArray(message.tool_calls));
+  assert.ok(assistantToolMessages.length > 0);
+  assert.equal(assistantToolMessages.every((message) => message.content === ""), true);
+});
+
+test("tool-loop exhaustion returns the latest successful result with a hard output cap", async () => {
+  const mainRounds = Array.from({ length: 16 }, (_, index) =>
+    toolCompletion("action_execute", index + 1)
+  );
+  const harness = createHarness(
+    [
+      ...mainRounds,
+      textCompletion("Let me prepare the answer."),
+      textCompletion("I'll summarize the result."),
+      textCompletion("Checking the final output.")
+    ],
+    {
+      executeToolCall(_request, sequence) {
+        return {
+          ok: true,
+          result: {
+            sequence,
+            payload: sequence === 16 ? "x".repeat(10_000) : "ok"
+          }
+        };
+      }
+    }
+  );
+
+  await harness.run();
+
+  const finalMessages = assistantMessages(harness.streamEvents);
+  assert.equal(harness.executedTools.length, 16);
+  assert.equal(harness.completionRequests.length, 19);
+  assert.equal(finalMessages.length, 1);
+  assert.ok(finalMessages[0].length <= 4000);
+  assert.match(finalMessages[0], /Latest successful result from action_execute/u);
+  assert.match(finalMessages[0], /"sequence": 16/u);
+  assert.match(finalMessages[0], /…\[truncated\]$/u);
+  assert.doesNotMatch(finalMessages[0], /Please narrow the request/u);
+  assert.equal(harness.streamEvents.some((event) => event.method === "sendAssistantDelta"), false);
+});