@jskit-ai/assistant-runtime 0.1.143 → 0.1.145

package/src/server/services/chatService.js

@@ -5,10 +5,16 @@ 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 CURRENT_TIME_PREFLIGHT_INTENT = "current-time";
+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 +32,7 @@ function normalizeHistory(history = []) {
       }
 
       const content = normalizeText(item.content).slice(0, MAX_INPUT_CHARS);
-      if (!content) {
+      if (!content || (role === "assistant" && isAssistantProgressOnlyText(content))) {
         return null;
       }
 
@@ -90,6 +96,36 @@ function isAbortError(error) {
   return String(error.name || "").trim() === "AbortError";
 }
 
+function requiresCurrentTime(value = "") {
+  const text = normalizeText(value);
+  if (!text) {
+    return false;
+  }
+
+  return [
+    /\b(?:now|today|tomorrow|yesterday|tonight)\b/iu,
+    /\b(?:current|local)\s+(?:date|day|time|date\s+and\s+time)\b/iu,
+    /\bwhat(?:'s|\s+is)\s+(?:the\s+)?(?:date|day|time)\b/iu,
+    /\b(?:this|next|last)\s+(?:day|week|month|year|monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b/iu
+  ].some((pattern) => pattern.test(text));
+}
+
+function resolvePreflightTools(toolDescriptors = [], input = "") {
+  if (!requiresCurrentTime(input)) {
+    return [];
+  }
+
+  const currentTimeTool = toolDescriptors.find((tool) => {
+    const intents = Array.isArray(tool?.preflight) ? tool.preflight : [];
+    const requiredParameters = Array.isArray(tool?.parameters?.required)
+      ? tool.parameters.required
+      : [];
+    return requiredParameters.length < 1 && intents.includes(CURRENT_TIME_PREFLIGHT_INTENT);
+  });
+
+  return currentTimeTool ? [currentTimeTool] : [];
+}
+
 function extractTextDelta(deltaContent) {
   if (typeof deltaContent === "string") {
     return deltaContent;
@@ -152,6 +188,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 +220,21 @@ 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
-    });
+  if (normalizeText(reason).toLowerCase() === "max_tool_rounds") {
+    return "Limit reached. Start a new conversation.";
   }
 
-  return "I reached the tool-call limit for this request. Please narrow the request and I will continue.";
+  return buildToolOutcomeFallbackAnswer({
+    toolFailures,
+    toolSuccesses
+  });
 }
 
 function toSafeToolResultText(value) {
@@ -217,26 +253,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 +284,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 +309,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 +366,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 +377,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 +418,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 +558,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 +713,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 +731,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",
@@ -902,6 +778,26 @@ function createChatService({
       const toolFailures = [];
       const toolSuccesses = [];
 
+      const preflightTools = resolvePreflightTools(toolSet.tools, source.input);
+      for (const [index, tool] of preflightTools.entries()) {
+        const toolCall = {
+          id: `assistant_preflight_${index + 1}`,
+          name: tool.name,
+          arguments: "{}"
+        };
+        messages.push(buildAssistantToolCallMessage([toolCall]));
+        const preflightFailures = await executeToolCalls([toolCall], {
+          toolFailures,
+          toolSuccesses
+        });
+        for (const failure of preflightFailures) {
+          const toolName = normalizeText(failure?.name);
+          if (toolName) {
+            excludedToolNames.add(toolName);
+          }
+        }
+      }
+
       for (let round = 0; round < MAX_TOOL_ROUNDS; round += 1) {
         const roundToolDescriptors = toolSet.tools.filter(
           (tool) => !excludedToolNames.has(normalizeText(tool.name))
@@ -914,18 +810,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 +826,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" }
+    ]
+  );
+});