@jskit-ai/assistant-runtime 0.1.193 → 0.1.194

package/src/server/services/chatService.js

@@ -2,20 +2,12 @@ import { isDeepStrictEqual } from "node:util";
 import { AppError } from "@jskit-ai/kernel/server/runtime";
 import { normalizeObject, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import { resolveWorkspaceSlug } from "@jskit-ai/assistant-core/server";
-import {
-  ASSISTANT_STREAM_EVENT_TYPES
-} from "@jskit-ai/assistant-core/shared";
+import { ASSISTANT_STREAM_EVENT_TYPES, isAssistantProgressOnlyText } 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 = 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 });
@@ -99,58 +91,6 @@ 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;
-  }
-
-  if (!Array.isArray(deltaContent)) {
-    return "";
-  }
-
-  return deltaContent
-    .map((entry) => {
-      if (typeof entry === "string") {
-        return entry;
-      }
-      if (!entry || typeof entry !== "object") {
-        return "";
-      }
-      return String(entry.text || "");
-    })
-    .join("");
-}
-
 function toCompactJson(value, fallback = "{}") {
   try {
     if (!value || typeof value !== "object") {
@@ -217,235 +157,6 @@ function buildSystemPrompt({ targetSurfaceId = "", toolDescriptors = [], workspa
   return promptSegments.join(" ");
 }
 
-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 sanitizeAssistantMessageText(value) {
-  let source = String(value || "");
-  if (!source) {
-    return "";
-  }
-
-  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,
-    /<(?:analysis|reasoning|think)>[\s\S]*?(?:<\/(?:analysis|reasoning|think)>|$)/gi
-  ];
-  for (const pattern of blockPatterns) {
-    source = source.replace(pattern, " ");
-  }
-
-  const inlineTagPatterns = [
-    /<[^>\n]*invoke\b[^>]*\/>/gi,
-    /<\/?[^>\n]*invoke[^>\n]*>/gi,
-    /<\/?[^>\n]*function_calls[^>\n]*>/gi,
-    /<\/?[^>\n]*tool_calls?[^>\n]*>/gi,
-    /<\/?[^>\n]*DSML[^>\n]*>/gi
-  ];
-  for (const pattern of inlineTagPatterns) {
-    source = source.replace(pattern, " ");
-  }
-
-  return source
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .join("\n");
-}
-
-function buildAssistantToolCallMessage(toolCalls = []) {
-  return {
-    role: "assistant",
-    content: "",
-    tool_calls: toolCalls.map((toolCall) => ({
-      id: toolCall.id,
-      type: "function",
-      function: {
-        name: toolCall.name,
-        arguments: toolCall.arguments
-      }
-    }))
-  };
-}
-
-function parseDsmlToolCallsFromText(value = "") {
-  const source = String(value || "");
-  if (!source) {
-    return [];
-  }
-
-  const functionCallsMatch = source.match(
-    /<[^>\n]*function_calls[^>\n]*>([\s\S]*?)<\/[^>\n]*function_calls>/i
-  );
-  if (!functionCallsMatch) {
-    return [];
-  }
-
-  const blockText = String(functionCallsMatch[1] || "");
-  if (!blockText) {
-    return [];
-  }
-
-  const calls = [];
-  const invokePattern = /<[^>\n]*invoke\b([^>]*)>([\s\S]*?)<\/[^>\n]*invoke>/gi;
-  let match = invokePattern.exec(blockText);
-  while (match) {
-    const attributes = String(match[1] || "");
-    const body = normalizeText(String(match[2] || ""));
-    const quotedNameMatch =
-      attributes.match(/\bname\s*=\s*"([^"]+)"/i) || attributes.match(/\bname\s*=\s*'([^']+)'/i);
-    const bareNameMatch = attributes.match(/\bname\s*=\s*([^\s"'/>]+)/i);
-    const name = normalizeText(quotedNameMatch?.[1] || bareNameMatch?.[1]);
-    if (name) {
-      calls.push({
-        id: `dsml_tool_call_${calls.length + 1}`,
-        name,
-        arguments: body && /^[\[{]/.test(body) ? body : "{}"
-      });
-    }
-
-    match = invokePattern.exec(blockText);
-  }
-
-  return calls;
-}
-
-async function consumeCompletionStream(stream, onText = () => {}) {
-  let assistantText = "";
-  const toolCallsByIndex = new Map();
-
-  for await (const chunk of stream) {
-    const choice = chunk?.choices?.[0] || {};
-    const delta = choice?.delta || {};
-
-    const textDelta = extractTextDelta(delta.content);
-    if (textDelta) {
-      assistantText += textDelta;
-      // An opening provider tag can be split between chunks. Keep it private
-      // until its boundary is known; complete internal blocks are stripped below.
-      const tagStart = assistantText.lastIndexOf("<");
-      const safeText = tagStart > assistantText.lastIndexOf(">") ? assistantText.slice(0, tagStart) : assistantText;
-      onText(sanitizeAssistantMessageText(safeText));
-    }
-
-    const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
-    for (const partialToolCall of toolCalls) {
-      const index = Number(partialToolCall?.index || 0);
-      const existing =
-        toolCallsByIndex.get(index) ||
-        {
-          id: normalizeText(partialToolCall?.id) || `tool_call_${index + 1}`,
-          name: "",
-          arguments: ""
-        };
-
-      if (partialToolCall?.id) {
-        existing.id = normalizeText(partialToolCall.id) || existing.id;
-      }
-      if (partialToolCall?.function?.name) {
-        existing.name += String(partialToolCall.function.name || "");
-      }
-      if (partialToolCall?.function?.arguments) {
-        existing.arguments += String(partialToolCall.function.arguments || "");
-      }
-
-      toolCallsByIndex.set(index, existing);
-    }
-  }
-
-  let toolCalls = [...toolCallsByIndex.values()].map((toolCall, index) => ({
-    id: normalizeText(toolCall.id) || `tool_call_${index + 1}`,
-    name: normalizeText(toolCall.name),
-    arguments: String(toolCall.arguments || "")
-  }));
-
-  if (toolCalls.length < 1) {
-    const parsedDsmlCalls = parseDsmlToolCallsFromText(assistantText);
-    if (parsedDsmlCalls.length > 0) {
-      toolCalls = parsedDsmlCalls;
-      assistantText = normalizeText(sanitizeAssistantMessageText(assistantText));
-    }
-  }
-
-  return {
-    assistantText,
-    toolCalls
-  };
-}
-
 function requireAssistantSurface(appConfig = {}, targetSurfaceId = "") {
   const assistantSurface = resolveAssistantSurfaceConfig(appConfig, targetSurfaceId);
   if (assistantSurface) {
@@ -463,6 +174,7 @@ function buildAssistantActionContext(context = {}, assistantSurface = {}) {
 }
 
 function createChatService({
+  conversationRuntime,
   aiClientFactory,
   turnRequests,
   attachments,
@@ -565,6 +277,7 @@ function createChatService({
     return result;
 
     async function executeTurn() {
+      if (typeof conversationRuntime?.open !== "function") throw new TypeError("Assistant streaming requires its common conversation runtime.");
       const conversationResult = await transcriptService.createConversationForTurn(
         assistantSurface,
         workspace,
@@ -587,8 +300,9 @@ function createChatService({
         throw new AppError(500, "Assistant failed to create conversation.");
       }
 
-      async function resolveFiles(attachmentIds) {
-        if (attachmentIds === undefined || (Array.isArray(attachmentIds) && !attachmentIds.length)) return { attachments: [], content: [] };
+      const resolvedAttachments = [];
+      async function prepareAttachments(attachmentIds) {
+        if (attachmentIds === undefined || (Array.isArray(attachmentIds) && !attachmentIds.length)) return;
         if (!Array.isArray(attachmentIds) || attachmentIds.length > 10 ||
             attachmentIds.some(id => typeof id !== "string" || !id || id.length > 256)) {
           throw new AppError(400, "Invalid attachment identifiers.");
@@ -596,422 +310,101 @@ function createChatService({
         if (!attachments?.resolve || !aiClient.supportsAttachments) {
           throw new AppError(400, "File attachments are not configured for this assistant.");
         }
-        // Only the application can authorize uploads and turn stored bytes into
-        // provider input. Browser-supplied paths, URLs and file contents are never used.
-        return attachments.resolve({ attachmentIds, context: assistantContext, workspace, conversation });
-      }
-      const files = await resolveFiles(source.attachmentIds);
-      const history = [];
-      for (const message of source.history) {
-        const previousFiles = await resolveFiles(message.attachmentIds);
-        history.push({ role: message.role, content: previousFiles.content.length
-          ? [{ type: "text", text: message.content }, ...previousFiles.content] : message.content });
+        // Preserve the facade's existing pre-admission authorization order.
+        // Only these server-resolved materials reach the common file reader.
+        const files = await attachments.resolve({ attachmentIds, context: assistantContext, workspace, conversation });
+        resolvedAttachments.push({ attachmentIds: [...attachmentIds], files });
       }
-
-      await transcriptService.appendMessage(
-        assistantSurface,
-        conversationId,
-        {
-          role: "user",
-          kind: "chat",
-          clientMessageSid: source.messageId,
-          contentText: source.input,
-          metadata: {
-            surfaceId: assistantSurface.targetSurfaceId,
-            ...(files.attachments.length ? { attachments: files.attachments } : {})
-          }
-        },
-        {
-          context: assistantContext,
-          workspace
-        }
-      );
-
+      await prepareAttachments(source.attachmentIds);
+      for (const message of source.history) await prepareAttachments(message.attachmentIds);
       const toolSet = serviceToolCatalog.resolveToolSet(assistantContext);
       const customSystemPrompt = await assistantConfigService.resolveSystemPrompt(
-        assistantSurface,
-        workspace,
-        {
-          surface: assistantSurface.targetSurfaceId
-        },
-        {
-          context: assistantContext,
-          input: payload
-        }
+        assistantSurface, workspace, { surface: assistantSurface.targetSurfaceId },
+        { context: assistantContext, input: payload }
       );
-      const systemPrompt = buildSystemPrompt({
-        targetSurfaceId: assistantSurface.targetSurfaceId,
-        toolDescriptors: toolSet.tools,
-        workspaceSlug: resolveWorkspaceSlug(assistantContext, payload),
-        customSystemPrompt
-      });
-
-      const messages = [
-        {
-          role: "system",
-          content: systemPrompt
-        },
-        ...history,
-        {
-          role: "user",
-          content: files.content.length ? [{ type: "text", text: source.input }, ...files.content] : source.input
-        }
-      ];
-
-      async function completeWithAssistantMessage(assistantMessageText, { metadata = {} } = {}) {
-        const normalizedAssistantMessageText = normalizeText(sanitizeAssistantMessageText(assistantMessageText));
-        if (!normalizedAssistantMessageText) {
-          throw new AppError(502, "Assistant returned no output.");
-        }
-
-        await transcriptService.appendMessage(
-          assistantSurface,
-          conversationId,
-          {
-            role: "assistant",
-            kind: "chat",
-            contentText: normalizedAssistantMessageText
-          },
-          {
-            context: assistantContext,
-            workspace
-          }
-        );
-
-        await transcriptService.completeConversation(
-          assistantSurface,
-          conversationId,
-          {
-            status: "completed",
-            metadata
-          },
-          {
-            context: assistantContext,
-            workspace
-          }
-        );
-
-        streamWriter.sendAssistantMessage({
-          type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE,
-          text: normalizedAssistantMessageText
-        });
-        streamWriter.sendDone({
-          type: ASSISTANT_STREAM_EVENT_TYPES.DONE,
-          messageId: source.messageId,
-          status: "completed"
-        });
-
-        return {
-          conversationId,
-          messageId: source.messageId,
-          status: "completed"
-        };
+      const configuration = { systemPrompt: buildSystemPrompt({
+        targetSurfaceId: assistantSurface.targetSurfaceId, toolDescriptors: toolSet.tools,
+        workspaceSlug: resolveWorkspaceSlug(assistantContext, payload), customSystemPrompt
+      }), ...(request.integrationId ? { integrationId: request.integrationId } : {}) };
+      const runtimeContext = { ...assistantContext, assistantRequest: {
+        conversation, workspace, history: source.history, resolvedAttachments
+      } };
+      let handle;
+      try { handle = await conversationRuntime.open({ id: conversationId, context: runtimeContext, configuration }); }
+      catch (error) {
+        if (error.code !== "conversation_configuration_mismatch") throw error;
+        handle = await conversationRuntime.open({ id: conversationId, context: runtimeContext });
+        await handle.configure(configuration);
       }
-
+      let turnId = null;
+      let displayedId = null;
       let displayedText = "";
-      async function consumeResponse(stream) {
-        if (displayedText) {
-          streamWriter.sendAssistantMessage({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE, text: "", status: "streaming" });
-          displayedText = "";
-        }
-        return consumeCompletionStream(stream, text => {
-          if (text === displayedText) return;
-          if (text.startsWith(displayedText)) {
-            streamWriter.sendAssistantDelta({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_DELTA, delta: text.slice(displayedText.length) });
-          } else {
-            streamWriter.sendAssistantMessage({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE, text, status: "streaming" });
+      const release = await handle.subscribe(event => {
+        if (event.type === "accepted" && event.messageId === source.messageId) turnId = event.turnId;
+        if (!turnId || event.turnId !== turnId) return;
+        if (event.type === "message" && ["assistant", "commentary"].includes(event.role)) {
+          if (displayedId !== event.messageId) {
+            if (displayedText) streamWriter.sendAssistantMessage({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE, text: "", status: "streaming" });
+            displayedId = event.messageId;
+            displayedText = "";
           }
-          displayedText = text;
-        });
-      }
-
-      async function executeToolCalls(toolCalls = [], { toolFailures = [], toolSuccesses = [] } = {}) {
-        const roundFailures = [];
-
-        for (const toolCall of toolCalls) {
-          streamWriter.sendToolCall({
-            type: ASSISTANT_STREAM_EVENT_TYPES.TOOL_CALL,
-            toolCallId: toolCall.id,
-            name: toolCall.name,
-            arguments: toolCall.arguments
-          });
-
-          await transcriptService.appendMessage(
-            assistantSurface,
-            conversationId,
-            {
-              role: "assistant",
-              kind: "tool_call",
-              contentText: toolCall.arguments,
-              metadata: {
-                toolCallId: toolCall.id,
-                tool: toolCall.name
-              }
-            },
-            {
-              context: assistantContext,
-              workspace
-            }
-          );
-
-          const toolResult = await serviceToolCatalog.executeToolCall({
-            toolName: toolCall.name,
-            argumentsText: toolCall.arguments,
-            context: assistantContext,
-            toolSet
-          });
-
-          await transcriptService.appendMessage(
-            assistantSurface,
-            conversationId,
-            {
-              role: "assistant",
-              kind: "tool_result",
-              contentText: JSON.stringify(toolResult),
-              metadata: {
-                toolCallId: toolCall.id,
-                tool: toolCall.name,
-                ok: toolResult.ok === true
-              }
-            },
-            {
-              context: assistantContext,
-              workspace
-            }
-          );
-
-          if (toolResult.ok) {
-            toolSuccesses.push({
-              name: toolCall.name,
-              result: toolResult.result
-            });
-            streamWriter.sendToolResult({
-              type: ASSISTANT_STREAM_EVENT_TYPES.TOOL_RESULT,
-              toolCallId: toolCall.id,
-              name: toolCall.name,
-              ok: true,
-              result: toolResult.result
-            });
-
-            messages.push({
-              role: "tool",
-              tool_call_id: toolCall.id,
-              content: JSON.stringify(toolResult.result ?? null)
-            });
-            continue;
-          }
-
-          const failure = {
-            name: toolCall.name,
-            error: toolResult.error
-          };
-          roundFailures.push(failure);
-          toolFailures.push(failure);
-
-          streamWriter.sendToolResult({
-            type: ASSISTANT_STREAM_EVENT_TYPES.TOOL_RESULT,
-            toolCallId: toolCall.id,
-            name: toolCall.name,
-            ok: false,
-            error: toolResult.error
-          });
-
-          messages.push({
-            role: "tool",
-            tool_call_id: toolCall.id,
-            content: JSON.stringify({
-              error: toolResult.error
-            })
-          });
+          if (event.text === displayedText) return;
+          if (event.text.startsWith(displayedText)) streamWriter.sendAssistantDelta({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_DELTA, delta: event.text.slice(displayedText.length) });
+          else streamWriter.sendAssistantMessage({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE, text: event.text, status: "streaming" });
+          displayedText = event.text;
+        } else if (event.type === "tool") {
+          const call = event.call;
+          if (call.status === "running") streamWriter.sendToolCall({ type: ASSISTANT_STREAM_EVENT_TYPES.TOOL_CALL,
+            toolCallId: call.id, name: call.name, arguments: call.arguments });
+          else if (call.result) streamWriter.sendToolResult({ type: ASSISTANT_STREAM_EVENT_TYPES.TOOL_RESULT,
+            toolCallId: call.id, name: call.name, ok: call.result.ok === true,
+            ...(call.result.ok ? { result: call.result.result } : { error: call.result.error }) });
         }
-
-        return roundFailures;
-      }
-
-      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 completionStream = await aiClient.createChatCompletionStream({
-            messages: recoveryMessages,
-            tools: [],
-            signal: options.abortSignal
-          });
-          const completion = await consumeResponse(completionStream);
-
-          const recoveryToolCalls = completion.toolCalls.filter((entry) => entry.name);
-          if (recoveryToolCalls.length > 0) {
-            continue;
-          }
-
-          const assistantMessageText = normalizeText(sanitizeAssistantMessageText(completion.assistantText));
-          if (assistantMessageText && !isAssistantProgressOnlyText(assistantMessageText)) {
-            return completeWithAssistantMessage(assistantMessageText, {
-              metadata: {
-                recoveryReason: reason || "unknown",
-                toolFailureCount: Array.isArray(toolFailures) ? toolFailures.length : 0
-              }
-            });
-          }
-        }
-
-        const fallbackText = buildRecoveryFallbackAnswer({
-          reason,
-          toolFailures,
-          toolSuccesses
-        });
-        return completeWithAssistantMessage(fallbackText, {
-          metadata: {
-            recoveryReason: reason || "unknown",
-            toolFailureCount: Array.isArray(toolFailures) ? toolFailures.length : 0
-          }
-        });
-      }
-
+      });
+      let cancellation;
+      const cancel = () => { cancellation ||= handle.cancel(); cancellation.catch(() => {}); };
       let streamed = false;
-
       try {
-        const receipt = {
-          type: ASSISTANT_STREAM_EVENT_TYPES.META,
-          messageId: source.messageId,
-          conversationId,
-          provider: aiClient.provider,
-          model: aiClient.defaultModel
-        };
-        await turnRequests.update(claim, { meta: receipt });
-        streamWriter.sendMeta(receipt);
+        const meta = { type: ASSISTANT_STREAM_EVENT_TYPES.META, messageId: source.messageId, conversationId,
+          provider: aiClient.provider, model: aiClient.defaultModel };
+        await turnRequests.update(claim, { meta });
+        streamWriter.sendMeta(meta);
         streamed = true;
-
-        const excludedToolNames = new Set();
-        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))
-          );
-          const roundToolSchemas = roundToolDescriptors.map((tool) => serviceToolCatalog.toOpenAiToolSchema(tool));
-
-          const completionStream = await aiClient.createChatCompletionStream({
-            messages,
-            tools: roundToolSchemas,
-            signal: options.abortSignal
-          });
-
-          const completion = await consumeResponse(completionStream);
-
-          const toolCalls = completion.toolCalls.filter((entry) => entry.name);
-          if (toolCalls.length < 1) {
-            const finalMessageText = normalizeText(sanitizeAssistantMessageText(completion.assistantText));
-            if (finalMessageText && !isAssistantProgressOnlyText(finalMessageText)) {
-              return completeWithAssistantMessage(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) {
-            for (const failure of roundFailures) {
-              const toolName = normalizeText(failure?.name);
-              if (toolName) {
-                excludedToolNames.add(toolName);
-              }
-            }
-          }
+        options.abortSignal?.addEventListener("abort", cancel, { once: true });
+        options.abortSignal?.throwIfAborted();
+        const receipt = await handle.send({ messageId: source.messageId, text: source.input,
+          ...(source.attachmentIds !== undefined ? { attachmentIds: source.attachmentIds } : {}) });
+        turnId = receipt.turnId;
+        const snapshot = await handle.wait();
+        const turn = snapshot.conversationLog.find(entry => entry.turnId === turnId);
+        const status = turn?.metadata?.runtime?.status;
+        if (status !== "complete") {
+          const error = new Error(turn?.metadata?.runtime?.error || snapshot.error || "Assistant request failed.");
+          if (status === "cancelled") error.name = "AbortError";
+          throw error;
         }
-
-        return recoverWithoutTools({
-          reason: toolFailures.length > 0 ? "tool_failure" : "max_tool_rounds",
-          toolFailures,
-          toolSuccesses
-        });
+        const text = normalizeText(turn.assistant?.text);
+        if (!text) throw new AppError(502, "Assistant returned no output.");
+        await transcriptService.completeConversation(assistantSurface, conversationId,
+          { status: "completed", metadata: turn.metadata?.completion || {} }, { context: assistantContext, workspace });
+        streamWriter.sendAssistantMessage({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE, text });
+        streamWriter.sendDone({ type: ASSISTANT_STREAM_EVENT_TYPES.DONE, messageId: source.messageId, status: "completed" });
+        return { conversationId, messageId: source.messageId, status: "completed" };
       } catch (error) {
-        const aborted = isAbortError(error);
+        const aborted = isAbortError(error) || options.abortSignal?.aborted;
         const status = aborted ? "aborted" : "failed";
-
-        if (streamed) {
-          await transcriptService.completeConversation(
-            assistantSurface,
-            conversationId,
-            {
-              status
-            },
-            {
-              context: assistantContext,
-              workspace
-            }
-          );
-
-          streamWriter.sendError({
-            type: ASSISTANT_STREAM_EVENT_TYPES.ERROR,
-            messageId: source.messageId,
-            code: aborted ? "assistant_stream_aborted" : String(error?.code || "assistant_stream_failed"),
-            message: aborted ? "Assistant request was cancelled." : String(error?.message || "Assistant request failed."),
-            status: aborted ? 499 : Number(error?.status || error?.statusCode || 500)
-          });
-
-          streamWriter.sendDone({
-            type: ASSISTANT_STREAM_EVENT_TYPES.DONE,
-            messageId: source.messageId,
-            status
-          });
-
-          return {
-            conversationId,
-            messageId: source.messageId,
-            status
-          };
-        }
-
-        throw error;
+        if (!streamed) throw error;
+        await transcriptService.completeConversation(assistantSurface, conversationId, { status }, { context: assistantContext, workspace });
+        streamWriter.sendError({ type: ASSISTANT_STREAM_EVENT_TYPES.ERROR, messageId: source.messageId,
+          code: aborted ? "assistant_stream_aborted" : String(error?.code || "assistant_stream_failed"),
+          message: aborted ? "Assistant request was cancelled." : String(error?.message || "Assistant request failed."),
+          status: aborted ? 499 : Number(error?.status || error?.statusCode || 500) });
+        streamWriter.sendDone({ type: ASSISTANT_STREAM_EVENT_TYPES.DONE, messageId: source.messageId, status });
+        return { conversationId, messageId: source.messageId, status };
+      } finally {
+        options.abortSignal?.removeEventListener("abort", cancel);
+        release();
+        await cancellation;
       }
     }
   }
@@ -1044,6 +437,7 @@ function createChatService({
   }
 
   return Object.freeze({
+    close: () => conversationRuntime?.close(),
     streamChat,
     listConversations,
     getConversationMessages