@dexto/core 1.2.6 → 1.4.0

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

@@ -0,0 +1,367 @@
+"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 stream_processor_exports = {};
+__export(stream_processor_exports, {
+  StreamProcessor: () => StreamProcessor
+});
+module.exports = __toCommonJS(stream_processor_exports);
+var import_tool_output_truncator = require("./tool-output-truncator.js");
+var import_utils = require("../../context/utils.js");
+var import_types3 = require("../../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(import_types3.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 (0, import_utils.sanitizeToolResult)(
+              rawResult,
+              {
+                blobStore: this.resourceManager.getBlobStore(),
+                toolName: event.toolName,
+                toolCallId: event.toolCallId,
+                success: true
+              },
+              this.logger
+            );
+            const truncated = (0, import_tool_output_truncator.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();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StreamProcessor
+});

package/dist/llm/executor/stream-processor.d.ts

@@ -0,0 +1,55 @@
+import { StreamTextResult, ToolSet as VercelToolSet } from 'ai';
+import { ContextManager } from '../../context/manager.js';
+import { SessionEventBus } from '../../events/index.js';
+import { ResourceManager } from '../../resources/index.js';
+import { StreamProcessorResult } from './types.js';
+import { IDextoLogger } from '../../logger/v2/types.js';
+import { LLMProvider } from '../types.js';
+export interface StreamProcessorConfig {
+    provider: LLMProvider;
+    model: string;
+}
+export declare class StreamProcessor {
+    private contextManager;
+    private eventBus;
+    private resourceManager;
+    private abortSignal;
+    private config;
+    private streaming;
+    private approvalMetadata?;
+    private assistantMessageId;
+    private actualTokens;
+    private finishReason;
+    private reasoningText;
+    private accumulatedText;
+    private 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.
+     */
+    private pendingToolCalls;
+    /**
+     * @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: ContextManager, eventBus: SessionEventBus, resourceManager: ResourceManager, abortSignal: AbortSignal, config: StreamProcessorConfig, logger: IDextoLogger, streaming?: boolean, approvalMetadata?: Map<string, {
+        requireApproval: boolean;
+        approvalStatus?: "approved" | "rejected";
+    }> | undefined);
+    process(streamFn: () => StreamTextResult<VercelToolSet, unknown>): Promise<StreamProcessorResult>;
+    private createAssistantMessage;
+    private getLastMessageId;
+    /**
+     * 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.
+     */
+    private persistCancelledToolResults;
+}
+//# sourceMappingURL=stream-processor.d.ts.map

package/dist/llm/executor/stream-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-processor.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/stream-processor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,IAAI,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAmB,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGnD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,OAAO,EAAE,WAAW,EAAc,MAAM,aAAa,CAAC;AAEtD,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,eAAe;IAwBpB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,MAAM;IAEd,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,gBAAgB,CAAC;IA9B7B,OAAO,CAAC,kBAAkB,CAAuB;IACjD,OAAO,CAAC,YAAY,CAAmE;IACvF,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,eAAe,CAAc;IACrC,OAAO,CAAC,MAAM,CAAe;IAC7B;;;OAGG;IACH,OAAO,CAAC,gBAAgB,CAAgD;IAExE;;;;;;;;;OASG;gBAES,cAAc,EAAE,cAAc,EAC9B,QAAQ,EAAE,eAAe,EACzB,eAAe,EAAE,eAAe,EAChC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,qBAAqB,EACrC,MAAM,EAAE,YAAY,EACZ,SAAS,GAAE,OAAc,EACzB,gBAAgB,CAAC,EAAE,GAAG,CAC1B,MAAM,EACN;QAAE,eAAe,EAAE,OAAO,CAAC;QAAC,cAAc,CAAC,EAAE,UAAU,GAAG,UAAU,CAAA;KAAE,CACzE,YAAA;IAKC,OAAO,CACT,QAAQ,EAAE,MAAM,gBAAgB,CAAC,aAAa,EAAE,OAAO,CAAC,GACzD,OAAO,CAAC,qBAAqB,CAAC;YAmYnB,sBAAsB;YAKtB,gBAAgB;IAO9B;;;;OAIG;YACW,2BAA2B;CAmC5C"}