@dexto/core 1.3.0 → 1.5.0

package/dist/llm/executor/turn-executor.js

@@ -0,0 +1,711 @@
+import {
+  __callDispose,
+  __using
+} from "../../chunk-PTJYTZNU.js";
+import {
+  streamText,
+  generateText,
+  stepCountIs,
+  jsonSchema,
+  APICallError
+} from "ai";
+import { trace } from "@opentelemetry/api";
+import { StreamProcessor } from "./stream-processor.js";
+import { DextoLogComponent } from "../../logger/v2/types.js";
+import { defer } from "../../utils/defer.js";
+import { DextoRuntimeError } from "../../errors/DextoRuntimeError.js";
+import { ErrorScope, ErrorType } from "../../errors/types.js";
+import { LLMErrorCode } from "../error-codes.js";
+import { toError } from "../../utils/error-conversion.js";
+import { isOverflow } from "../../context/compaction/overflow.js";
+import { ReactiveOverflowStrategy } from "../../context/compaction/strategies/reactive-overflow.js";
+const toolSupportCache = /* @__PURE__ */ new Map();
+const LOCAL_PROVIDERS = ["ollama", "local"];
+class TurnExecutor {
+  constructor(model, toolManager, contextManager, eventBus, resourceManager, sessionId, config, llmContext, logger, messageQueue, modelLimits, externalSignal, compactionStrategy) {
+    this.model = model;
+    this.toolManager = toolManager;
+    this.contextManager = contextManager;
+    this.eventBus = eventBus;
+    this.resourceManager = resourceManager;
+    this.sessionId = sessionId;
+    this.config = config;
+    this.llmContext = llmContext;
+    this.messageQueue = messageQueue;
+    this.modelLimits = modelLimits;
+    this.externalSignal = externalSignal;
+    this.logger = logger.createChild(DextoLogComponent.EXECUTOR);
+    this.stepAbortController = new AbortController();
+    if (compactionStrategy !== void 0) {
+      this.compactionStrategy = compactionStrategy;
+    } else if (modelLimits) {
+      this.compactionStrategy = new ReactiveOverflowStrategy(model, {}, this.logger);
+    }
+  }
+  logger;
+  /**
+   * Per-step abort controller. Created fresh for each iteration of the loop.
+   * This allows soft cancel (abort current step) while still continuing with queued messages.
+   */
+  stepAbortController;
+  compactionStrategy = null;
+  /**
+   * Map to track approval metadata by toolCallId.
+   * Used to pass approval info from tool execution to result persistence.
+   */
+  approvalMetadata = /* @__PURE__ */ new Map();
+  /**
+   * Get StreamProcessor config from TurnExecutor state.
+   */
+  getStreamProcessorConfig() {
+    return {
+      provider: this.llmContext.provider,
+      model: this.llmContext.model
+    };
+  }
+  /**
+   * Main agent execution loop.
+   * Uses stopWhen: stepCountIs(1) to regain control after each step.
+   *
+   * @param contributorContext Context for system prompt contributors
+   * @param streaming If true, emits llm:chunk events during streaming. Default true.
+   */
+  async execute(contributorContext, streaming = true) {
+    var _stack = [];
+    try {
+      const _ = __using(_stack, defer(() => this.cleanup()));
+      const startTime = Date.now();
+      let stepCount = 0;
+      let lastStepTokens = null;
+      let lastFinishReason = "unknown";
+      let lastText = "";
+      this.eventBus.emit("llm:thinking");
+      const supportsTools = await this.validateToolSupport();
+      if (!supportsTools) {
+        const modelKey = `${this.llmContext.provider}:${this.llmContext.model}`;
+        this.eventBus.emit("llm:unsupported-input", {
+          errors: [
+            `Model '${modelKey}' does not support tool calling.`,
+            "You can still chat, but the model will not be able to use tools or execute commands."
+          ],
+          provider: this.llmContext.provider,
+          model: this.llmContext.model,
+          details: {
+            feature: "tool-calling",
+            supported: false
+          }
+        });
+        this.logger.warn(
+          `Model ${modelKey} does not support tools - continuing without tool calling`
+        );
+      }
+      let currentAbortHandler = null;
+      try {
+        while (true) {
+          if (currentAbortHandler && this.externalSignal) {
+            this.externalSignal.removeEventListener("abort", currentAbortHandler);
+          }
+          this.stepAbortController = new AbortController();
+          currentAbortHandler = () => this.stepAbortController.abort();
+          if (this.externalSignal && !this.externalSignal.aborted) {
+            this.externalSignal.addEventListener("abort", currentAbortHandler, {
+              once: true
+            });
+          }
+          const coalesced = this.messageQueue.dequeueAll();
+          if (coalesced) {
+            await this.injectQueuedMessages(coalesced);
+          }
+          if (lastStepTokens && this.checkAndHandleOverflow(lastStepTokens)) {
+            await this.compress(lastStepTokens.inputTokens ?? 0);
+          }
+          const prepared = await this.contextManager.getFormattedMessagesWithCompression(
+            contributorContext,
+            this.llmContext
+          );
+          this.logger.debug(`Step ${stepCount}: Starting`);
+          const tools = supportsTools ? await this.createTools() : {};
+          const streamProcessor = new StreamProcessor(
+            this.contextManager,
+            this.eventBus,
+            this.resourceManager,
+            this.stepAbortController.signal,
+            this.getStreamProcessorConfig(),
+            this.logger,
+            streaming,
+            this.approvalMetadata
+          );
+          const result = await streamProcessor.process(
+            () => streamText({
+              model: this.model,
+              stopWhen: stepCountIs(1),
+              tools,
+              abortSignal: this.stepAbortController.signal,
+              messages: prepared.formattedMessages,
+              ...this.config.maxOutputTokens !== void 0 && {
+                maxOutputTokens: this.config.maxOutputTokens
+              },
+              ...this.config.temperature !== void 0 && {
+                temperature: this.config.temperature
+              },
+              // Log stream-level errors (tool errors, API errors during streaming)
+              onError: (error) => {
+                this.logger.error("Stream error", { error });
+              }
+            })
+          );
+          lastStepTokens = result.usage;
+          lastFinishReason = result.finishReason;
+          lastText = result.text;
+          this.logger.debug(
+            `Step ${stepCount}: Finished with reason="${result.finishReason}", tokens=${JSON.stringify(result.usage)}`
+          );
+          if (result.finishReason !== "tool-calls") {
+            const queuedOnTerminate = this.messageQueue.dequeueAll();
+            if (queuedOnTerminate) {
+              this.logger.debug(
+                `Continuing: ${queuedOnTerminate.messages.length} queued message(s) to process`
+              );
+              await this.injectQueuedMessages(queuedOnTerminate);
+              continue;
+            }
+            this.logger.debug(`Terminating: finishReason is "${result.finishReason}"`);
+            break;
+          }
+          if (this.externalSignal?.aborted && !this.messageQueue.hasPending()) {
+            this.logger.debug("Terminating: hard cancel - external abort signal received");
+            lastFinishReason = "cancelled";
+            break;
+          }
+          if (++stepCount >= this.config.maxSteps) {
+            this.logger.debug(`Terminating: reached maxSteps (${this.config.maxSteps})`);
+            lastFinishReason = "max-steps";
+            break;
+          }
+          await this.pruneOldToolOutputs();
+        }
+      } catch (error) {
+        const mappedError = this.mapProviderError(error);
+        this.logger.error("TurnExecutor failed", { error: mappedError });
+        this.eventBus.emit("llm:error", {
+          error: mappedError,
+          context: "TurnExecutor",
+          recoverable: false
+        });
+        await this.contextManager.flush();
+        this.eventBus.emit("run:complete", {
+          finishReason: "error",
+          stepCount,
+          durationMs: Date.now() - startTime,
+          error: mappedError
+        });
+        throw mappedError;
+      }
+      await this.contextManager.flush();
+      this.setTelemetryAttributes(lastStepTokens);
+      this.eventBus.emit("run:complete", {
+        finishReason: lastFinishReason,
+        stepCount,
+        durationMs: Date.now() - startTime
+      });
+      return {
+        text: lastText,
+        stepCount,
+        usage: lastStepTokens,
+        finishReason: lastFinishReason
+      };
+    } catch (_2) {
+      var _error = _2, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  /**
+   * Abort the current step execution.
+   * Note: For full run cancellation, use the external abort signal.
+   */
+  abort() {
+    this.stepAbortController.abort();
+  }
+  /**
+   * Inject coalesced queued messages into the context as a single user message.
+   * This enables mid-task user guidance.
+   */
+  async injectQueuedMessages(coalesced) {
+    await this.contextManager.addMessage({
+      role: "user",
+      content: coalesced.combinedContent,
+      metadata: {
+        coalesced: coalesced.messages.length > 1,
+        messageCount: coalesced.messages.length,
+        originalMessageIds: coalesced.messages.map((m) => m.id)
+      }
+    });
+    this.logger.info(`Injected ${coalesced.messages.length} queued message(s) into context`, {
+      count: coalesced.messages.length,
+      firstQueued: coalesced.firstQueuedAt,
+      lastQueued: coalesced.lastQueuedAt
+    });
+  }
+  /**
+   * Validates if the current model supports tools.
+   * Uses a static cache to avoid repeated validation calls.
+   *
+   * For local providers (Ollama, local) and custom baseURL endpoints, makes a test call to verify tool support.
+   * Known cloud providers without baseURL are assumed to support tools.
+   */
+  async validateToolSupport() {
+    const modelKey = `${this.llmContext.provider}:${this.llmContext.model}:${this.config.baseURL ?? ""}`;
+    if (toolSupportCache.has(modelKey)) {
+      return toolSupportCache.get(modelKey);
+    }
+    const isLocalProvider = LOCAL_PROVIDERS.includes(this.llmContext.provider);
+    if (!this.config.baseURL && !isLocalProvider) {
+      this.logger.debug(
+        `Skipping tool validation for ${modelKey} - known cloud provider without custom baseURL`
+      );
+      toolSupportCache.set(modelKey, true);
+      return true;
+    }
+    this.logger.debug(
+      `Testing tool support for ${isLocalProvider ? "local provider" : "custom endpoint"} model: ${modelKey}`
+    );
+    const testTool = {
+      test_tool: {
+        inputSchema: jsonSchema({
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }),
+        execute: async () => ({ result: "test" })
+      }
+    };
+    const testAbort = new AbortController();
+    const testTimeout = setTimeout(() => testAbort.abort(), 5e3);
+    try {
+      await generateText({
+        model: this.model,
+        messages: [{ role: "user", content: "Hello" }],
+        tools: testTool,
+        stopWhen: stepCountIs(1),
+        abortSignal: testAbort.signal
+      });
+      clearTimeout(testTimeout);
+      toolSupportCache.set(modelKey, true);
+      this.logger.debug(`Model ${modelKey} supports tools`);
+      return true;
+    } catch (error) {
+      clearTimeout(testTimeout);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("does not support tools")) {
+        toolSupportCache.set(modelKey, false);
+        this.logger.debug(
+          `Detected that model ${modelKey} does not support tool calling - tool functionality will be disabled`
+        );
+        return false;
+      }
+      this.logger.debug(
+        `Tool validation error for ${modelKey}, assuming supported: ${errorMessage}`
+      );
+      toolSupportCache.set(modelKey, true);
+      return true;
+    }
+  }
+  /**
+   * Creates tools with execute callbacks and toModelOutput.
+   *
+   * Key design decisions:
+   * - execute() returns raw result with inline images (async)
+   * - toModelOutput() formats for LLM consumption (sync)
+   * - StreamProcessor handles persistence via tool-result events
+   */
+  async createTools() {
+    const tools = await this.toolManager.getAllTools();
+    return Object.fromEntries(
+      Object.entries(tools).map(([name, tool]) => [
+        name,
+        {
+          inputSchema: jsonSchema(tool.parameters),
+          ...tool.description && { description: tool.description },
+          /**
+           * Execute callback - runs the tool and returns raw result.
+           * Does NOT persist - StreamProcessor handles that on tool-result event.
+           *
+           * Uses Promise.race to ensure we return quickly on abort, even if the
+           * underlying tool (especially MCP tools we don't control) keeps running.
+           */
+          execute: async (args, options) => {
+            this.logger.debug(
+              `Executing tool: ${name} (toolCallId: ${options.toolCallId})`
+            );
+            const abortSignal = this.stepAbortController.signal;
+            if (abortSignal.aborted) {
+              this.logger.debug(`Tool ${name} cancelled before execution`);
+              return { error: "Cancelled by user", cancelled: true };
+            }
+            let abortHandler = null;
+            const abortPromise = new Promise(
+              (resolve) => {
+                abortHandler = () => {
+                  this.logger.debug(`Tool ${name} cancelled during execution`);
+                  resolve({ error: "Cancelled by user", cancelled: true });
+                };
+                abortSignal.addEventListener("abort", abortHandler, { once: true });
+              }
+            );
+            try {
+              const result = await Promise.race([
+                (async () => {
+                  const executionResult = await this.toolManager.executeTool(
+                    name,
+                    args,
+                    options.toolCallId,
+                    this.sessionId,
+                    abortSignal
+                  );
+                  if (executionResult.requireApproval !== void 0) {
+                    const metadata = {
+                      requireApproval: executionResult.requireApproval
+                    };
+                    if (executionResult.approvalStatus !== void 0) {
+                      metadata.approvalStatus = executionResult.approvalStatus;
+                    }
+                    this.approvalMetadata.set(options.toolCallId, metadata);
+                  }
+                  return executionResult.result;
+                })(),
+                abortPromise
+              ]);
+              return result;
+            } finally {
+              if (abortHandler) {
+                abortSignal.removeEventListener("abort", abortHandler);
+              }
+            }
+          },
+          /**
+           * toModelOutput - formats raw result for LLM consumption.
+           * Called by Vercel SDK when preparing messages for next LLM call.
+           * SYNC - images are already inline in the raw result.
+           */
+          toModelOutput: (result) => {
+            return this.formatToolResultForLLM(result, name);
+          }
+        }
+      ])
+    );
+  }
+  /**
+   * Format tool result for LLM consumption.
+   * Handles multimodal content (text + images).
+   *
+   * This handles RAW tool results - the structure may vary.
+   */
+  formatToolResultForLLM(result, toolName) {
+    if (result && typeof result === "object" && "error" in result) {
+      const errorResult = result;
+      let errorFlags = "";
+      if (errorResult.denied) errorFlags += " (denied)";
+      if (errorResult.timeout) errorFlags += " (timeout)";
+      return {
+        type: "text",
+        value: `Tool ${toolName} failed${errorFlags}: ${errorResult.error}`
+      };
+    }
+    if (this.hasMultimodalContent(result)) {
+      const contentArray = result.content;
+      const contentValue = [];
+      for (const part of contentArray) {
+        if (part.type === "text" && typeof part.text === "string") {
+          contentValue.push({ type: "text", text: part.text });
+        } else if (part.type === "image") {
+          const imageData = this.extractImageData(part);
+          if (imageData) {
+            contentValue.push({
+              type: "media",
+              data: imageData,
+              mediaType: part.mimeType || "image/jpeg"
+            });
+          }
+        } else if (part.type === "file") {
+          const fileData = this.extractFileData(part);
+          if (fileData) {
+            contentValue.push({
+              type: "media",
+              data: fileData,
+              mediaType: part.mimeType || "application/octet-stream"
+            });
+          }
+        }
+      }
+      if (contentValue.length > 0 && contentValue.some((v) => v.type === "media")) {
+        return { type: "content", value: contentValue };
+      }
+      const textParts = contentArray.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text);
+      return {
+        type: "text",
+        value: textParts.join("\n") || "[empty result]"
+      };
+    }
+    if (typeof result === "string") {
+      return { type: "text", value: result };
+    }
+    return {
+      type: "text",
+      value: typeof result === "object" && result !== null ? JSON.stringify(result) : String(result)
+    };
+  }
+  /**
+   * Extract image data from a part, handling various formats.
+   */
+  extractImageData(part) {
+    if (typeof part.image === "string") {
+      return part.image;
+    }
+    if (typeof part.data === "string") {
+      return part.data;
+    }
+    if (part.image instanceof Buffer) {
+      return part.image.toString("base64");
+    }
+    if (part.data instanceof Buffer) {
+      return part.data.toString("base64");
+    }
+    if (part.image instanceof ArrayBuffer) {
+      return Buffer.from(new Uint8Array(part.image)).toString("base64");
+    }
+    if (part.data instanceof ArrayBuffer) {
+      return Buffer.from(new Uint8Array(part.data)).toString("base64");
+    }
+    return null;
+  }
+  /**
+   * Extract file data from a part.
+   */
+  extractFileData(part) {
+    if (typeof part.data === "string") {
+      return part.data;
+    }
+    if (part.data instanceof Buffer) {
+      return part.data.toString("base64");
+    }
+    if (part.data instanceof ArrayBuffer) {
+      return Buffer.from(new Uint8Array(part.data)).toString("base64");
+    }
+    return null;
+  }
+  /**
+   * Check if result has multimodal content array
+   */
+  hasMultimodalContent(result) {
+    return result !== null && typeof result === "object" && "content" in result && Array.isArray(result.content);
+  }
+  /**
+   * Constants for pruning thresholds
+   */
+  static PRUNE_PROTECT = 4e4;
+  // Keep last 40K tokens of tool outputs
+  static PRUNE_MINIMUM = 2e4;
+  // Only prune if we can save 20K+
+  /**
+   * Prunes old tool outputs by marking them with compactedAt timestamp.
+   * Does NOT modify content - transformation happens at format time in
+   * ContextManager.getFormattedMessagesWithCompression().
+   *
+   * Algorithm:
+   * 1. Go backwards through history (most recent first)
+   * 2. Stop at summary message (only process post-summary messages)
+   * 3. Count tool message tokens
+   * 4. If total exceeds PRUNE_PROTECT, mark older ones for pruning
+   * 5. Only prune if savings exceed PRUNE_MINIMUM
+   */
+  async pruneOldToolOutputs() {
+    const history = await this.contextManager.getHistory();
+    let totalToolTokens = 0;
+    let prunedTokens = 0;
+    const toPrune = [];
+    for (let i = history.length - 1; i >= 0; i--) {
+      const msg = history[i];
+      if (!msg) continue;
+      if (msg.metadata?.isSummary === true) break;
+      if (msg.role !== "tool") continue;
+      if (msg.compactedAt) continue;
+      if (!Array.isArray(msg.content)) continue;
+      const tokens = this.estimateToolTokens(msg.content);
+      totalToolTokens += tokens;
+      if (totalToolTokens > TurnExecutor.PRUNE_PROTECT && msg.id) {
+        prunedTokens += tokens;
+        toPrune.push(msg.id);
+      }
+    }
+    if (prunedTokens > TurnExecutor.PRUNE_MINIMUM && toPrune.length > 0) {
+      const markedCount = await this.contextManager.markMessagesAsCompacted(toPrune);
+      this.eventBus.emit("context:pruned", {
+        prunedCount: markedCount,
+        savedTokens: prunedTokens
+      });
+      this.logger.debug(`Pruned ${markedCount} tool outputs, saving ~${prunedTokens} tokens`);
+      return { prunedCount: markedCount, savedTokens: prunedTokens };
+    }
+    return { prunedCount: 0, savedTokens: 0 };
+  }
+  /**
+   * Estimates tokens for tool message content using simple heuristic (length/4).
+   * Used for pruning decisions only - actual token counts come from API.
+   *
+   * Tool message content is always Array<TextPart | ImagePart | FilePart | UIResourcePart>
+   * after sanitization via SanitizedToolResult.
+   */
+  estimateToolTokens(content) {
+    return content.reduce((sum, part) => {
+      if (part.type === "text") {
+        return sum + Math.ceil(part.text.length / 4);
+      }
+      if (part.type === "image" || part.type === "file") {
+        return sum + 1e3;
+      }
+      return sum;
+    }, 0);
+  }
+  /**
+   * Cleanup resources when execution scope exits.
+   * Called automatically via defer() on normal exit, throw, or abort.
+   */
+  cleanup() {
+    this.logger.debug("TurnExecutor cleanup triggered");
+    if (!this.stepAbortController.signal.aborted) {
+      this.stepAbortController.abort();
+    }
+    this.messageQueue.clear();
+  }
+  /**
+   * Check if context has overflowed based on actual token usage from API.
+   */
+  checkAndHandleOverflow(tokens) {
+    if (!this.modelLimits || !this.compactionStrategy) {
+      return false;
+    }
+    return isOverflow(tokens, this.modelLimits);
+  }
+  /**
+   * Compress context using ReactiveOverflowStrategy.
+   *
+   * Generates a summary of older messages and adds it to history.
+   * The actual token reduction happens at read-time via filterCompacted()
+   * in getFormattedMessagesWithCompression().
+   *
+   * @param originalTokens The actual input token count from API that triggered overflow
+   */
+  async compress(originalTokens) {
+    if (!this.compactionStrategy) {
+      return;
+    }
+    this.logger.info(
+      `Context overflow detected (${originalTokens} tokens), running compression`
+    );
+    const history = await this.contextManager.getHistory();
+    const summaryMessages = await this.compactionStrategy.compact(history);
+    if (summaryMessages.length === 0) {
+      this.logger.debug("Compaction returned no summary (history too short)");
+      return;
+    }
+    for (const summary of summaryMessages) {
+      await this.contextManager.addMessage(summary);
+    }
+    const { filterCompacted, estimateMessagesTokens } = await import("../../context/utils.js");
+    const updatedHistory = await this.contextManager.getHistory();
+    const filteredHistory = filterCompacted(updatedHistory);
+    const compactedTokens = estimateMessagesTokens(filteredHistory);
+    this.eventBus.emit("context:compacted", {
+      originalTokens,
+      compactedTokens,
+      originalMessages: history.length,
+      compactedMessages: filteredHistory.length,
+      strategy: this.compactionStrategy.name,
+      reason: "overflow"
+    });
+    this.logger.info(
+      `Compaction complete: ${originalTokens} \u2192 ~${compactedTokens} tokens (${history.length} \u2192 ${filteredHistory.length} messages after filtering)`
+    );
+  }
+  /**
+   * Set telemetry span attributes for token usage.
+   */
+  setTelemetryAttributes(usage) {
+    const activeSpan = trace.getActiveSpan();
+    if (!activeSpan || !usage) {
+      return;
+    }
+    if (usage.inputTokens !== void 0) {
+      activeSpan.setAttribute("gen_ai.usage.input_tokens", usage.inputTokens);
+    }
+    if (usage.outputTokens !== void 0) {
+      activeSpan.setAttribute("gen_ai.usage.output_tokens", usage.outputTokens);
+    }
+    if (usage.totalTokens !== void 0) {
+      activeSpan.setAttribute("gen_ai.usage.total_tokens", usage.totalTokens);
+    }
+    if (usage.reasoningTokens !== void 0) {
+      activeSpan.setAttribute("gen_ai.usage.reasoning_tokens", usage.reasoningTokens);
+    }
+  }
+  /**
+   * Map provider errors to DextoRuntimeError.
+   */
+  mapProviderError(err) {
+    if (APICallError.isInstance?.(err)) {
+      const status = err.statusCode;
+      const headers = err.responseHeaders || {};
+      const retryAfter = headers["retry-after"] ? Number(headers["retry-after"]) : void 0;
+      const body = typeof err.responseBody === "string" ? err.responseBody : JSON.stringify(err.responseBody ?? "");
+      if (status === 429) {
+        return new DextoRuntimeError(
+          LLMErrorCode.RATE_LIMIT_EXCEEDED,
+          ErrorScope.LLM,
+          ErrorType.RATE_LIMIT,
+          `Rate limit exceeded${body ? ` - ${body}` : ""}`,
+          {
+            sessionId: this.sessionId,
+            provider: this.llmContext.provider,
+            model: this.llmContext.model,
+            status,
+            retryAfter,
+            body
+          }
+        );
+      }
+      if (status === 408) {
+        return new DextoRuntimeError(
+          LLMErrorCode.GENERATION_FAILED,
+          ErrorScope.LLM,
+          ErrorType.TIMEOUT,
+          `Provider timed out${body ? ` - ${body}` : ""}`,
+          {
+            sessionId: this.sessionId,
+            provider: this.llmContext.provider,
+            model: this.llmContext.model,
+            status,
+            body
+          }
+        );
+      }
+      return new DextoRuntimeError(
+        LLMErrorCode.GENERATION_FAILED,
+        ErrorScope.LLM,
+        ErrorType.THIRD_PARTY,
+        `Provider error ${status}${body ? ` - ${body}` : ""}`,
+        {
+          sessionId: this.sessionId,
+          provider: this.llmContext.provider,
+          model: this.llmContext.model,
+          status,
+          body
+        }
+      );
+    }
+    return toError(err, this.logger);
+  }
+}
+export {
+  TurnExecutor
+};