@dexto/core 1.3.0 → 1.4.0

package/dist/llm/executor/stream-processor.js

@@ -0,0 +1,344 @@
+import "../../chunk-PTJYTZNU.js";
+import { truncateToolResult } from "./tool-output-truncator.js";
+import { sanitizeToolResult } from "../../context/utils.js";
+import { DextoLogComponent } from "../../logger/v2/types.js";
+class StreamProcessor {
+  /**
+   * @param contextManager Context manager for message persistence
+   * @param eventBus Event bus for emitting events
+   * @param resourceManager Resource manager for blob storage
+   * @param abortSignal Abort signal for cancellation
+   * @param config Provider/model configuration
+   * @param logger Logger instance
+   * @param streaming If true, emits llm:chunk events. Default true.
+   * @param approvalMetadata Map of tool call IDs to approval metadata
+   */
+  constructor(contextManager, eventBus, resourceManager, abortSignal, config, logger, streaming = true, approvalMetadata) {
+    this.contextManager = contextManager;
+    this.eventBus = eventBus;
+    this.resourceManager = resourceManager;
+    this.abortSignal = abortSignal;
+    this.config = config;
+    this.streaming = streaming;
+    this.approvalMetadata = approvalMetadata;
+    this.logger = logger.createChild(DextoLogComponent.EXECUTOR);
+  }
+  assistantMessageId = null;
+  actualTokens = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  finishReason = "unknown";
+  reasoningText = "";
+  accumulatedText = "";
+  logger;
+  /**
+   * Track pending tool calls (added to context but no result yet).
+   * On cancel/abort, we add synthetic "cancelled" results to maintain tool_use/tool_result pairing.
+   */
+  pendingToolCalls = /* @__PURE__ */ new Map();
+  async process(streamFn) {
+    const stream = streamFn();
+    try {
+      for await (const event of stream.fullStream) {
+        switch (event.type) {
+          case "text-delta":
+            if (!this.assistantMessageId) {
+              this.assistantMessageId = await this.contextManager.addAssistantMessage("", [], {}).then(() => {
+                return this.getLastMessageId();
+              });
+            }
+            await this.contextManager.appendAssistantText(
+              this.assistantMessageId,
+              event.text
+            );
+            this.accumulatedText += event.text;
+            if (this.streaming) {
+              this.eventBus.emit("llm:chunk", {
+                chunkType: "text",
+                content: event.text
+              });
+            }
+            break;
+          case "reasoning-delta":
+            this.reasoningText += event.text;
+            if (this.streaming) {
+              this.eventBus.emit("llm:chunk", {
+                chunkType: "reasoning",
+                content: event.text
+              });
+            }
+            break;
+          case "tool-call":
+            if (!this.assistantMessageId) {
+              this.assistantMessageId = await this.createAssistantMessage();
+            }
+            await this.contextManager.addToolCall(this.assistantMessageId, {
+              id: event.toolCallId,
+              type: "function",
+              function: {
+                name: event.toolName,
+                arguments: JSON.stringify(event.input)
+              }
+            });
+            this.pendingToolCalls.set(event.toolCallId, {
+              toolName: event.toolName
+            });
+            break;
+          case "tool-result": {
+            const rawResult = event.output;
+            this.logger.debug("Tool result received", {
+              toolName: event.toolName,
+              toolCallId: event.toolCallId,
+              rawResult
+            });
+            const sanitized = await sanitizeToolResult(
+              rawResult,
+              {
+                blobStore: this.resourceManager.getBlobStore(),
+                toolName: event.toolName,
+                toolCallId: event.toolCallId,
+                success: true
+              },
+              this.logger
+            );
+            const truncated = truncateToolResult(sanitized);
+            const approval = this.approvalMetadata?.get(event.toolCallId);
+            await this.contextManager.addToolResult(
+              event.toolCallId,
+              event.toolName,
+              truncated,
+              // Includes meta.success from sanitization
+              approval
+              // Only approval metadata if present
+            );
+            this.eventBus.emit("llm:tool-result", {
+              toolName: event.toolName,
+              callId: event.toolCallId,
+              success: true,
+              sanitized: truncated,
+              rawResult,
+              ...approval?.requireApproval !== void 0 && {
+                requireApproval: approval.requireApproval
+              },
+              ...approval?.approvalStatus !== void 0 && {
+                approvalStatus: approval.approvalStatus
+              }
+            });
+            this.approvalMetadata?.delete(event.toolCallId);
+            this.pendingToolCalls.delete(event.toolCallId);
+            break;
+          }
+          case "finish-step":
+            if (event.usage) {
+              const cacheWriteTokens = event.providerMetadata?.["anthropic"]?.["cacheCreationInputTokens"] ?? // @ts-expect-error - Bedrock metadata typing not in Vercel SDK
+              event.providerMetadata?.["bedrock"]?.["usage"]?.["cacheWriteInputTokens"] ?? 0;
+              this.actualTokens = {
+                inputTokens: (this.actualTokens.inputTokens ?? 0) + (event.usage.inputTokens ?? 0),
+                outputTokens: (this.actualTokens.outputTokens ?? 0) + (event.usage.outputTokens ?? 0),
+                totalTokens: (this.actualTokens.totalTokens ?? 0) + (event.usage.totalTokens ?? 0),
+                ...event.usage.reasoningTokens !== void 0 && {
+                  reasoningTokens: (this.actualTokens.reasoningTokens ?? 0) + event.usage.reasoningTokens
+                },
+                // Cache tokens
+                cacheReadTokens: (this.actualTokens.cacheReadTokens ?? 0) + (event.usage.cachedInputTokens ?? 0),
+                cacheWriteTokens: (this.actualTokens.cacheWriteTokens ?? 0) + cacheWriteTokens
+              };
+            }
+            break;
+          case "finish": {
+            this.finishReason = event.finishReason;
+            const cachedInputTokens = event.totalUsage.cachedInputTokens ?? 0;
+            const providerExcludesCached = this.config.provider === "anthropic" || this.config.provider === "bedrock";
+            const adjustedInputTokens = providerExcludesCached ? event.totalUsage.inputTokens ?? 0 : (event.totalUsage.inputTokens ?? 0) - cachedInputTokens;
+            const usage = {
+              inputTokens: adjustedInputTokens,
+              outputTokens: event.totalUsage.outputTokens ?? 0,
+              totalTokens: event.totalUsage.totalTokens ?? 0,
+              // Capture reasoning tokens if available (from Claude extended thinking, etc.)
+              ...event.totalUsage.reasoningTokens !== void 0 && {
+                reasoningTokens: event.totalUsage.reasoningTokens
+              },
+              // Cache tokens - read from totalUsage, write from accumulated finish-step events
+              cacheReadTokens: cachedInputTokens,
+              cacheWriteTokens: this.actualTokens.cacheWriteTokens ?? 0
+            };
+            this.actualTokens = usage;
+            this.logger.info("LLM response complete", {
+              finishReason: event.finishReason,
+              contentLength: this.accumulatedText.length,
+              content: this.accumulatedText,
+              ...this.reasoningText && {
+                reasoningLength: this.reasoningText.length,
+                reasoning: this.reasoningText
+              },
+              usage,
+              provider: this.config.provider,
+              model: this.config.model
+            });
+            if (this.assistantMessageId) {
+              await this.contextManager.updateAssistantMessage(
+                this.assistantMessageId,
+                {
+                  tokenUsage: usage
+                }
+              );
+            }
+            const hasContent = this.accumulatedText || this.reasoningText;
+            if (this.finishReason !== "tool-calls" || hasContent) {
+              this.eventBus.emit("llm:response", {
+                content: this.accumulatedText,
+                ...this.reasoningText && { reasoning: this.reasoningText },
+                provider: this.config.provider,
+                model: this.config.model,
+                tokenUsage: usage,
+                finishReason: this.finishReason
+              });
+            }
+            break;
+          }
+          case "tool-error": {
+            this.logger.error("Tool execution failed", {
+              toolName: event.toolName,
+              toolCallId: event.toolCallId,
+              error: event.error
+            });
+            const errorMessage = event.error instanceof Error ? event.error.message : String(event.error);
+            const errorResult = {
+              content: [{ type: "text", text: `Error: ${errorMessage}` }],
+              meta: {
+                toolName: event.toolName,
+                toolCallId: event.toolCallId,
+                success: false
+              }
+            };
+            await this.contextManager.addToolResult(
+              event.toolCallId,
+              event.toolName,
+              errorResult,
+              void 0
+              // No approval metadata for errors
+            );
+            this.eventBus.emit("llm:tool-result", {
+              toolName: event.toolName,
+              callId: event.toolCallId,
+              success: false,
+              error: errorMessage
+            });
+            this.eventBus.emit("llm:error", {
+              error: event.error instanceof Error ? event.error : new Error(String(event.error)),
+              context: `Tool execution failed: ${event.toolName}`,
+              toolCallId: event.toolCallId,
+              recoverable: true
+              // Tool errors are typically recoverable
+            });
+            this.pendingToolCalls.delete(event.toolCallId);
+            break;
+          }
+          case "error": {
+            const err = event.error instanceof Error ? event.error : new Error(String(event.error));
+            this.logger.error(`LLM error: ${err.toString()}}`);
+            this.eventBus.emit("llm:error", {
+              error: err
+            });
+            break;
+          }
+          case "abort":
+            this.logger.debug("Stream aborted, emitting partial response");
+            this.finishReason = "cancelled";
+            await this.persistCancelledToolResults();
+            this.eventBus.emit("llm:response", {
+              content: this.accumulatedText,
+              ...this.reasoningText && { reasoning: this.reasoningText },
+              provider: this.config.provider,
+              model: this.config.model,
+              tokenUsage: this.actualTokens,
+              finishReason: "cancelled"
+            });
+            return {
+              text: this.accumulatedText,
+              finishReason: "cancelled",
+              usage: this.actualTokens
+            };
+        }
+      }
+    } catch (error) {
+      const isAbortError = error instanceof Error && error.name === "AbortError" || this.abortSignal.aborted;
+      if (isAbortError) {
+        this.logger.debug("Stream cancelled, emitting partial response");
+        this.finishReason = "cancelled";
+        await this.persistCancelledToolResults();
+        this.eventBus.emit("llm:response", {
+          content: this.accumulatedText,
+          ...this.reasoningText && { reasoning: this.reasoningText },
+          provider: this.config.provider,
+          model: this.config.model,
+          tokenUsage: this.actualTokens,
+          finishReason: "cancelled"
+        });
+        return {
+          text: this.accumulatedText,
+          finishReason: "cancelled",
+          usage: this.actualTokens
+        };
+      }
+      this.logger.error("Stream processing failed", { error });
+      this.eventBus.emit("llm:error", {
+        error: error instanceof Error ? error : new Error(String(error)),
+        context: "StreamProcessor",
+        recoverable: false
+      });
+      throw error;
+    }
+    return {
+      text: this.accumulatedText,
+      finishReason: this.finishReason,
+      usage: this.actualTokens
+    };
+  }
+  async createAssistantMessage() {
+    await this.contextManager.addAssistantMessage("", [], {});
+    return this.getLastMessageId();
+  }
+  async getLastMessageId() {
+    const history = await this.contextManager.getHistory();
+    const last = history[history.length - 1];
+    if (!last || !last.id) throw new Error("Failed to get last message ID");
+    return last.id;
+  }
+  /**
+   * Persist synthetic "cancelled" results for all pending tool calls.
+   * This maintains the tool_use/tool_result pairing required by LLM APIs.
+   * Called on abort/cancel to prevent "tool_use ids were found without tool_result" errors.
+   */
+  async persistCancelledToolResults() {
+    if (this.pendingToolCalls.size === 0) return;
+    this.logger.debug(
+      `Persisting cancelled results for ${this.pendingToolCalls.size} pending tool call(s)`
+    );
+    for (const [toolCallId, { toolName }] of this.pendingToolCalls) {
+      const cancelledResult = {
+        content: [{ type: "text", text: "Cancelled by user" }],
+        meta: {
+          toolName,
+          toolCallId,
+          success: false
+        }
+      };
+      await this.contextManager.addToolResult(
+        toolCallId,
+        toolName,
+        cancelledResult,
+        void 0
+        // No approval metadata for cancelled tools
+      );
+      this.eventBus.emit("llm:tool-result", {
+        toolName,
+        callId: toolCallId,
+        success: false,
+        error: "Cancelled by user"
+      });
+    }
+    this.pendingToolCalls.clear();
+  }
+}
+export {
+  StreamProcessor
+};

package/dist/llm/executor/tool-output-truncator.cjs

@@ -0,0 +1,75 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tool_output_truncator_exports = {};
+__export(tool_output_truncator_exports, {
+  DEFAULT_MAX_FILE_LINES: () => DEFAULT_MAX_FILE_LINES,
+  DEFAULT_MAX_LINE_LENGTH: () => DEFAULT_MAX_LINE_LENGTH,
+  DEFAULT_MAX_TOOL_OUTPUT_CHARS: () => DEFAULT_MAX_TOOL_OUTPUT_CHARS,
+  truncateStringOutput: () => truncateStringOutput,
+  truncateToolResult: () => truncateToolResult
+});
+module.exports = __toCommonJS(tool_output_truncator_exports);
+const DEFAULT_MAX_TOOL_OUTPUT_CHARS = 12e4;
+const DEFAULT_MAX_FILE_LINES = 2e3;
+const DEFAULT_MAX_LINE_LENGTH = 2e3;
+function truncateStringOutput(output, options = {}) {
+  const maxChars = options.maxChars ?? DEFAULT_MAX_TOOL_OUTPUT_CHARS;
+  if (output.length <= maxChars) {
+    return {
+      output,
+      truncated: false,
+      originalLength: output.length
+    };
+  }
+  const truncatedOutput = output.slice(0, maxChars) + `
+
+[Output truncated - exceeded maximum length of ${maxChars} characters. Total length was ${output.length} characters.]`;
+  return {
+    output: truncatedOutput,
+    truncated: true,
+    originalLength: output.length
+  };
+}
+function truncateToolResult(result, options = {}) {
+  const newContent = result.content.map((part) => {
+    if (part.type === "text") {
+      const { output, truncated } = truncateStringOutput(part.text, options);
+      if (truncated) {
+        return { ...part, text: output };
+      }
+    }
+    return part;
+  });
+  return {
+    ...result,
+    content: newContent,
+    meta: {
+      ...result.meta
+      // We could add a flag here if we wanted to track truncation in metadata
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_MAX_FILE_LINES,
+  DEFAULT_MAX_LINE_LENGTH,
+  DEFAULT_MAX_TOOL_OUTPUT_CHARS,
+  truncateStringOutput,
+  truncateToolResult
+});

package/dist/llm/executor/tool-output-truncator.d.ts

@@ -0,0 +1,27 @@
+import { SanitizedToolResult } from '../../context/types.js';
+export declare const DEFAULT_MAX_TOOL_OUTPUT_CHARS = 120000;
+export declare const DEFAULT_MAX_FILE_LINES = 2000;
+export declare const DEFAULT_MAX_LINE_LENGTH = 2000;
+export interface TruncationOptions {
+    maxChars?: number;
+}
+export interface TruncationResult {
+    output: string;
+    truncated: boolean;
+    originalLength: number;
+}
+/**
+ * Truncates a string tool output to prevent context overflow.
+ * Appends a warning message if truncated.
+ */
+export declare function truncateStringOutput(output: string, options?: TruncationOptions): TruncationResult;
+/**
+ * Truncates a SanitizedToolResult.
+ * Currently only truncates text parts.
+ *
+ * @param result The sanitized tool result to truncate
+ * @param options Truncation options
+ * @returns The truncated result
+ */
+export declare function truncateToolResult(result: SanitizedToolResult, options?: TruncationOptions): SanitizedToolResult;
+//# sourceMappingURL=tool-output-truncator.d.ts.map

package/dist/llm/executor/tool-output-truncator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-output-truncator.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/tool-output-truncator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAG7D,eAAO,MAAM,6BAA6B,SAAU,CAAC;AACrD,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAC3C,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAE5C,MAAM,WAAW,iBAAiB;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAChC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,iBAAsB,GAChC,gBAAgB,CAoBlB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAC9B,MAAM,EAAE,mBAAmB,EAC3B,OAAO,GAAE,iBAAsB,GAChC,mBAAmB,CAmBrB"}

package/dist/llm/executor/tool-output-truncator.js

@@ -0,0 +1,48 @@
+import "../../chunk-PTJYTZNU.js";
+const DEFAULT_MAX_TOOL_OUTPUT_CHARS = 12e4;
+const DEFAULT_MAX_FILE_LINES = 2e3;
+const DEFAULT_MAX_LINE_LENGTH = 2e3;
+function truncateStringOutput(output, options = {}) {
+  const maxChars = options.maxChars ?? DEFAULT_MAX_TOOL_OUTPUT_CHARS;
+  if (output.length <= maxChars) {
+    return {
+      output,
+      truncated: false,
+      originalLength: output.length
+    };
+  }
+  const truncatedOutput = output.slice(0, maxChars) + `
+
+[Output truncated - exceeded maximum length of ${maxChars} characters. Total length was ${output.length} characters.]`;
+  return {
+    output: truncatedOutput,
+    truncated: true,
+    originalLength: output.length
+  };
+}
+function truncateToolResult(result, options = {}) {
+  const newContent = result.content.map((part) => {
+    if (part.type === "text") {
+      const { output, truncated } = truncateStringOutput(part.text, options);
+      if (truncated) {
+        return { ...part, text: output };
+      }
+    }
+    return part;
+  });
+  return {
+    ...result,
+    content: newContent,
+    meta: {
+      ...result.meta
+      // We could add a flag here if we wanted to track truncation in metadata
+    }
+  };
+}
+export {
+  DEFAULT_MAX_FILE_LINES,
+  DEFAULT_MAX_LINE_LENGTH,
+  DEFAULT_MAX_TOOL_OUTPUT_CHARS,
+  truncateStringOutput,
+  truncateToolResult
+};