@jskit-ai/assistant-core 0.2.6 → 0.2.8

package/src/server/lib/assistantToolLoop.js

@@ -1,259 +0,0 @@
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { isAssistantProgressOnlyText } from "../../shared/assistantResponseText.js";
-import { sanitizeAssistantMessageText } from "./assistantCompletion.js";
-
-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 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 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 buildRecoveryPrompt({ reason = "", toolFailures = [], toolSuccesses = [] } = {}) {
-  const normalizedReason = normalizeText(reason).toLowerCase();
-  const failureSummary = (Array.isArray(toolFailures) ? toolFailures : [])
-    .slice(0, 3)
-    .map((entry) => {
-      const toolName = normalizeText(entry?.name) || "unknown_tool";
-      const errorCode = normalizeText(entry?.error?.code) || "tool_failed";
-      return `${toolName}:${errorCode}`;
-    })
-    .filter(Boolean)
-    .join(", ");
-  const successSummary = (Array.isArray(toolSuccesses) ? toolSuccesses : [])
-    .slice(0, 3)
-    .map((entry) => normalizeText(entry?.name))
-    .filter(Boolean)
-    .join(", ");
-
-  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. ${COMPLETION_INSTRUCTION}${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 = [] } = {}) {
-  if (normalizeText(reason).toLowerCase() === "max_tool_rounds") {
-    return "Limit reached. Start a new conversation.";
-  }
-
-  return buildToolOutcomeFallbackAnswer({
-    toolFailures,
-    toolSuccesses
-  });
-}
-
-function toSafeToolResultText(value) {
-  if (value == null) {
-    return "null";
-  }
-  if (typeof value === "string") {
-    const normalized = normalizeText(value);
-    return normalized || "\"\"";
-  }
-  try {
-    return JSON.stringify(value, null, 2);
-  } catch {
-    return "\"<unserializable>\"";
-  }
-}
-
-function buildToolOutcomeFallbackAnswer({ toolFailures = [], toolSuccesses = [] } = {}) {
-  const successfulResults = (Array.isArray(toolSuccesses) ? toolSuccesses : [])
-    .filter((entry) => normalizeText(entry?.name));
-  const hasFailures = Array.isArray(toolFailures) && toolFailures.length > 0;
-
-  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;
-    }
-
-    const suffix = "\n…[truncated]";
-    return `${answer.slice(0, MAX_TOOL_RESULT_FALLBACK_CHARS - suffix.length)}${suffix}`;
-  }
-
-  if (hasFailures) {
-    return "I could not gather additional information from successful operations.";
-  }
-
-  return "I could not gather additional information from the available operations.";
-}
-
-function buildAssistantToolCallMessage(toolCalls = []) {
-  return {
-    role: "assistant",
-    content: "",
-    tool_calls: toolCalls.map((toolCall) => ({
-      id: toolCall.id,
-      type: "function",
-      function: {
-        name: toolCall.name,
-        arguments: toolCall.arguments
-      }
-    }))
-  };
-}
-
-/** Existing bounded inference/recovery policy; callers own delivery and tool receipts. */
-async function runAssistantToolLoop({ messages, input, toolSet, toToolSchema, complete, executeToolCalls, finish,
-  preserveWhitespace = false }) {
-  const answerText = value => preserveWhitespace
-    ? sanitizeAssistantMessageText(value, { preserveWhitespace: true })
-    : normalizeText(sanitizeAssistantMessageText(value));
-
-  async function recoverWithoutTools({ reason = "", toolFailures = [], toolSuccesses = [] } = {}) {
-    for (let pass = 0; pass < MAX_RECOVERY_PASSES; pass += 1) {
-      const recoveryMessages = [
-        ...messages,
-        {
-          role: "system",
-          content: buildRecoveryPrompt({
-            reason,
-            toolFailures,
-            toolSuccesses
-          })
-        }
-      ];
-
-      const completion = await complete(recoveryMessages, []);
-
-      const recoveryToolCalls = completion.toolCalls.filter((entry) => entry.name);
-      if (recoveryToolCalls.length > 0) {
-        continue;
-      }
-
-      const assistantMessageText = answerText(completion.assistantText);
-      if (assistantMessageText && !isAssistantProgressOnlyText(assistantMessageText)) {
-        return finish(assistantMessageText, {
-          metadata: {
-            recoveryReason: reason || "unknown",
-            toolFailureCount: Array.isArray(toolFailures) ? toolFailures.length : 0
-          }
-        });
-      }
-    }
-
-    const fallbackText = buildRecoveryFallbackAnswer({
-      reason,
-      toolFailures,
-      toolSuccesses
-    });
-    return finish(fallbackText, {
-      metadata: {
-        recoveryReason: reason || "unknown",
-        toolFailureCount: Array.isArray(toolFailures) ? toolFailures.length : 0
-      }
-    });
-  }
-
-  const excludedToolNames = new Set();
-  const toolFailures = [];
-  const toolSuccesses = [];
-
-  function excludeFailedTools(failures) {
-    for (const failure of failures) {
-      const toolName = normalizeText(failure?.name);
-      if (toolName && !(failure?.error?.status >= 400 && failure.error.status < 500)) {
-        excludedToolNames.add(toolName);
-      }
-    }
-  }
-
-  const preflightTools = resolvePreflightTools(toolSet.tools, 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
-    });
-    excludeFailedTools(preflightFailures);
-  }
-
-  for (let round = 0; round < MAX_TOOL_ROUNDS; round += 1) {
-    const roundToolDescriptors = toolSet.tools.filter(
-      (tool) => !excludedToolNames.has(normalizeText(tool.name))
-    );
-    const roundToolSchemas = roundToolDescriptors.map((tool) => toToolSchema(tool));
-
-    const completion = await complete(messages, roundToolSchemas);
-
-    const toolCalls = completion.toolCalls.filter((entry) => entry.name);
-    if (toolCalls.length < 1) {
-      const finalMessageText = answerText(completion.assistantText);
-      if (finalMessageText && !isAssistantProgressOnlyText(finalMessageText)) {
-        return finish(finalMessageText, {
-          metadata: toolFailures.length > 0
-            ? {
-                recoveryReason: "tool_failure",
-                toolFailureCount: toolFailures.length
-              }
-            : {}
-        });
-      }
-
-      messages.push({
-        role: "system",
-        content: COMPLETION_INSTRUCTION
-      });
-      continue;
-    }
-
-    messages.push(buildAssistantToolCallMessage(toolCalls));
-
-    const roundFailures = await executeToolCalls(toolCalls, {
-      toolFailures,
-      toolSuccesses
-    });
-
-    if (roundFailures.length > 0) {
-      excludeFailedTools(roundFailures);
-    }
-  }
-
-  return recoverWithoutTools({
-    reason: toolFailures.length > 0 ? "tool_failure" : "max_tool_rounds",
-    toolFailures,
-    toolSuccesses
-  });
-}
-
-export { runAssistantToolLoop };