@dexto/core 1.3.0 → 1.5.0

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

@@ -0,0 +1,780 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+var turn_executor_exports = {};
+__export(turn_executor_exports, {
+  TurnExecutor: () => TurnExecutor
+});
+module.exports = __toCommonJS(turn_executor_exports);
+var import_ai = require("ai");
+var import_api = require("@opentelemetry/api");
+var import_stream_processor = require("./stream-processor.js");
+var import_types4 = require("../../logger/v2/types.js");
+var import_defer = require("../../utils/defer.js");
+var import_DextoRuntimeError = require("../../errors/DextoRuntimeError.js");
+var import_types7 = require("../../errors/types.js");
+var import_error_codes = require("../error-codes.js");
+var import_error_conversion = require("../../utils/error-conversion.js");
+var import_overflow = require("../../context/compaction/overflow.js");
+var import_reactive_overflow = require("../../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(import_types4.DextoLogComponent.EXECUTOR);
+    this.stepAbortController = new AbortController();
+    if (compactionStrategy !== void 0) {
+      this.compactionStrategy = compactionStrategy;
+    } else if (modelLimits) {
+      this.compactionStrategy = new import_reactive_overflow.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, (0, import_defer.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 import_stream_processor.StreamProcessor(
+            this.contextManager,
+            this.eventBus,
+            this.resourceManager,
+            this.stepAbortController.signal,
+            this.getStreamProcessorConfig(),
+            this.logger,
+            streaming,
+            this.approvalMetadata
+          );
+          const result = await streamProcessor.process(
+            () => (0, import_ai.streamText)({
+              model: this.model,
+              stopWhen: (0, import_ai.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: (0, import_ai.jsonSchema)({
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }),
+        execute: async () => ({ result: "test" })
+      }
+    };
+    const testAbort = new AbortController();
+    const testTimeout = setTimeout(() => testAbort.abort(), 5e3);
+    try {
+      await (0, import_ai.generateText)({
+        model: this.model,
+        messages: [{ role: "user", content: "Hello" }],
+        tools: testTool,
+        stopWhen: (0, import_ai.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: (0, import_ai.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 (0, import_overflow.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 = import_api.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 (import_ai.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 import_DextoRuntimeError.DextoRuntimeError(
+          import_error_codes.LLMErrorCode.RATE_LIMIT_EXCEEDED,
+          import_types7.ErrorScope.LLM,
+          import_types7.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 import_DextoRuntimeError.DextoRuntimeError(
+          import_error_codes.LLMErrorCode.GENERATION_FAILED,
+          import_types7.ErrorScope.LLM,
+          import_types7.ErrorType.TIMEOUT,
+          `Provider timed out${body ? ` - ${body}` : ""}`,
+          {
+            sessionId: this.sessionId,
+            provider: this.llmContext.provider,
+            model: this.llmContext.model,
+            status,
+            body
+          }
+        );
+      }
+      return new import_DextoRuntimeError.DextoRuntimeError(
+        import_error_codes.LLMErrorCode.GENERATION_FAILED,
+        import_types7.ErrorScope.LLM,
+        import_types7.ErrorType.THIRD_PARTY,
+        `Provider error ${status}${body ? ` - ${body}` : ""}`,
+        {
+          sessionId: this.sessionId,
+          provider: this.llmContext.provider,
+          model: this.llmContext.model,
+          status,
+          body
+        }
+      );
+    }
+    return (0, import_error_conversion.toError)(err, this.logger);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TurnExecutor
+});