@dexto/core 1.7.2 → 1.8.1

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

@@ -1,27 +1,24 @@
-import "../../chunk-PTJYTZNU.js";
-import { truncateToolResult } from "./tool-output-truncator.js";
-import { sanitizeToolResult } from "../../context/utils.js";
+import "../../chunk-C6A6W6XS.js";
 import { DextoLogComponent } from "../../logger/v2/types.js";
 import { getUsagePricingMetadata } from "../usage-metadata.js";
+function finiteUsageCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
 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 toolCallMetadata Map of tool call IDs to tool-call metadata (approval + presentation)
    */
-  constructor(contextManager, eventBus, resourceManager, abortSignal, config, logger, streaming = true, toolCallMetadata) {
+  constructor(contextManager, eventBus, abortSignal, config, logger, streaming = true) {
     this.contextManager = contextManager;
     this.eventBus = eventBus;
-    this.resourceManager = resourceManager;
     this.abortSignal = abortSignal;
     this.config = config;
     this.streaming = streaming;
-    this.toolCallMetadata = toolCallMetadata;
     this.logger = logger.createChild(DextoLogComponent.EXECUTOR);
     this.usageScopeId = config.usageScopeId;
   }
@@ -34,6 +31,7 @@ class StreamProcessor {
   logger;
   hasStepUsage = false;
   usageScopeId;
+  modelToolCalls = [];
   /**
    * 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.
@@ -148,60 +146,14 @@ class StreamProcessor {
               };
             }
             await this.contextManager.addToolCall(this.assistantMessageId, toolCall);
-            this.pendingToolCalls.set(event.toolCallId, {
-              toolName: event.toolName
-            });
-            this.partialToolCalls.delete(event.toolCallId);
-            break;
-          }
-          case "tool-result": {
-            const rawResult = event.output;
-            this.logger.debug("Tool result received", {
-              toolName: event.toolName,
+            this.modelToolCalls.push({
               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 metadata = this.toolCallMetadata?.get(event.toolCallId);
-            await this.contextManager.addToolResult(
-              event.toolCallId,
-              event.toolName,
-              truncated,
-              // Includes meta.success from sanitization
-              metadata
-              // Only tool-call metadata if present
-            );
-            this.eventBus.emit("llm:tool-result", {
               toolName: event.toolName,
-              ...metadata?.presentationSnapshot !== void 0 && {
-                presentationSnapshot: metadata.presentationSnapshot
-              },
-              ...metadata?.meta !== void 0 && {
-                meta: metadata.meta
-              },
-              callId: event.toolCallId,
-              success: true,
-              sanitized: truncated,
-              rawResult,
-              ...metadata?.requireApproval !== void 0 && {
-                requireApproval: metadata.requireApproval
-              },
-              ...metadata?.approvalStatus !== void 0 && {
-                approvalStatus: metadata.approvalStatus
-              }
+              input: event.input
+            });
+            this.pendingToolCalls.set(event.toolCallId, {
+              toolName: event.toolName
             });
-            this.toolCallMetadata?.delete(event.toolCallId);
-            this.pendingToolCalls.delete(event.toolCallId);
             this.partialToolCalls.delete(event.toolCallId);
             break;
           }
@@ -292,58 +244,6 @@ class StreamProcessor {
             }
             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 metadata = this.toolCallMetadata?.get(event.toolCallId);
-            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,
-              metadata
-            );
-            this.eventBus.emit("llm:tool-result", {
-              toolName: event.toolName,
-              ...metadata?.presentationSnapshot !== void 0 && {
-                presentationSnapshot: metadata.presentationSnapshot
-              },
-              ...metadata?.meta !== void 0 && {
-                meta: metadata.meta
-              },
-              callId: event.toolCallId,
-              success: false,
-              error: errorMessage,
-              ...metadata?.requireApproval !== void 0 && {
-                requireApproval: metadata.requireApproval
-              },
-              ...metadata?.approvalStatus !== void 0 && {
-                approvalStatus: metadata.approvalStatus
-              }
-            });
-            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.toolCallMetadata?.delete(event.toolCallId);
-            this.pendingToolCalls.delete(event.toolCallId);
-            this.partialToolCalls.delete(event.toolCallId);
-            break;
-          }
           case "error": {
             const err = event.error instanceof Error ? event.error : new Error(String(event.error));
             await this.persistFailedToolResults(err.message);
@@ -370,7 +270,8 @@ class StreamProcessor {
             return {
               text: this.accumulatedText,
               finishReason: "cancelled",
-              usage: this.actualTokens
+              usage: this.actualTokens,
+              toolCalls: this.modelToolCalls
             };
           }
         }
@@ -398,7 +299,8 @@ class StreamProcessor {
         return {
           text: this.accumulatedText,
           finishReason: "cancelled",
-          usage: this.actualTokens
+          usage: this.actualTokens,
+          toolCalls: this.modelToolCalls
         };
       }
       this.logger.error("Stream processing failed", { error });
@@ -407,28 +309,29 @@ class StreamProcessor {
     return {
       text: this.accumulatedText,
       finishReason: this.finishReason,
-      usage: this.actualTokens
+      usage: this.actualTokens,
+      toolCalls: this.modelToolCalls
     };
   }
   getCacheTokensFromProviderMetadata(providerMetadata) {
     const anthropicMeta = providerMetadata?.["anthropic"];
     const bedrockMeta = providerMetadata?.["bedrock"];
-    const cacheWriteTokens = anthropicMeta?.["cacheCreationInputTokens"] ?? bedrockMeta?.usage?.["cacheWriteInputTokens"] ?? 0;
-    const cacheReadTokens = anthropicMeta?.["cacheReadInputTokens"] ?? bedrockMeta?.usage?.["cacheReadInputTokens"] ?? 0;
+    const cacheWriteTokens = finiteUsageCount(anthropicMeta?.["cacheCreationInputTokens"]) ?? finiteUsageCount(bedrockMeta?.usage?.["cacheWriteInputTokens"]) ?? 0;
+    const cacheReadTokens = finiteUsageCount(anthropicMeta?.["cacheReadInputTokens"]) ?? finiteUsageCount(bedrockMeta?.usage?.["cacheReadInputTokens"]) ?? 0;
     return { cacheReadTokens, cacheWriteTokens };
   }
   normalizeUsage(usage, providerMetadata) {
-    const inputTokensRaw = usage?.inputTokens ?? 0;
-    const outputTokens = usage?.outputTokens ?? 0;
-    const totalTokens = usage?.totalTokens ?? 0;
-    const reasoningTokens = usage?.reasoningTokens;
-    const cachedInputTokens = usage?.cachedInputTokens;
+    const inputTokensRaw = finiteUsageCount(usage?.inputTokens) ?? 0;
+    const outputTokens = finiteUsageCount(usage?.outputTokens) ?? 0;
+    const totalTokens = finiteUsageCount(usage?.totalTokens) ?? 0;
+    const reasoningTokens = finiteUsageCount(usage?.reasoningTokens);
+    const cachedInputTokens = finiteUsageCount(usage?.cachedInputTokens);
     const inputTokenDetails = usage?.inputTokenDetails;
     const providerCache = this.getCacheTokensFromProviderMetadata(providerMetadata);
-    const cacheReadTokens = inputTokenDetails?.cacheReadTokens ?? cachedInputTokens ?? providerCache.cacheReadTokens ?? 0;
-    const cacheWriteTokens = inputTokenDetails?.cacheWriteTokens ?? providerCache.cacheWriteTokens ?? 0;
+    const cacheReadTokens = finiteUsageCount(inputTokenDetails?.cacheReadTokens) ?? cachedInputTokens ?? providerCache.cacheReadTokens ?? 0;
+    const cacheWriteTokens = finiteUsageCount(inputTokenDetails?.cacheWriteTokens) ?? providerCache.cacheWriteTokens ?? 0;
     const needsCacheWriteAdjustment = inputTokenDetails === void 0 && cachedInputTokens !== void 0 && providerCache.cacheWriteTokens > 0;
-    const noCacheTokens = inputTokenDetails?.noCacheTokens ?? (cachedInputTokens !== void 0 ? inputTokensRaw - cachedInputTokens - (needsCacheWriteAdjustment ? providerCache.cacheWriteTokens : 0) : inputTokensRaw);
+    const noCacheTokens = finiteUsageCount(inputTokenDetails?.noCacheTokens) ?? (cachedInputTokens !== void 0 ? inputTokensRaw - cachedInputTokens - (needsCacheWriteAdjustment ? providerCache.cacheWriteTokens : 0) : inputTokensRaw);
     return {
       inputTokens: Math.max(0, noCacheTokens),
       outputTokens,
@@ -559,7 +462,6 @@ class StreamProcessor {
       `Persisting ${options.logLabel} results for ${this.pendingToolCalls.size} pending tool call(s)`
     );
     for (const [toolCallId, { toolName }] of this.pendingToolCalls) {
-      const metadata = this.toolCallMetadata?.get(toolCallId);
       const syntheticResult = {
         content: [{ type: "text", text: options.resultText }],
         meta: {
@@ -572,27 +474,14 @@ class StreamProcessor {
         toolCallId,
         toolName,
         syntheticResult,
-        metadata
+        void 0
       );
       this.eventBus.emit("llm:tool-result", {
         toolName,
-        ...metadata?.presentationSnapshot !== void 0 && {
-          presentationSnapshot: metadata.presentationSnapshot
-        },
-        ...metadata?.meta !== void 0 && {
-          meta: metadata.meta
-        },
         callId: toolCallId,
         success: false,
-        error: options.errorMessage,
-        ...metadata?.requireApproval !== void 0 && {
-          requireApproval: metadata.requireApproval
-        },
-        ...metadata?.approvalStatus !== void 0 && {
-          approvalStatus: metadata.approvalStatus
-        }
+        error: options.errorMessage
       });
-      this.toolCallMetadata?.delete(toolCallId);
     }
     this.pendingToolCalls.clear();
   }

package/dist/llm/{reasoning/profiles/openai.cjs → executor/tool-definitions.cjs}

@@ -16,26 +16,30 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var openai_exports = {};
-__export(openai_exports, {
-  buildOpenAIReasoningProfile: () => buildOpenAIReasoningProfile
+var tool_definitions_exports = {};
+__export(tool_definitions_exports, {
+  createModelToolDefinitions: () => createModelToolDefinitions
 });
-module.exports = __toCommonJS(openai_exports);
-var import_openai_reasoning_effort = require("../openai-reasoning-effort.js");
-var import_shared = require("./shared.js");
-function buildOpenAIReasoningProfile(model) {
-  const efforts = (0, import_openai_reasoning_effort.getSupportedOpenAIReasoningEfforts)(model);
-  return (0, import_shared.withDefault)(
-    {
-      capable: true,
-      paradigm: "effort",
-      variants: efforts.map((effort) => (0, import_shared.option)(effort)),
-      supportsBudgetTokens: false
-    },
-    "medium"
-  );
+module.exports = __toCommonJS(tool_definitions_exports);
+var import_ai = require("ai");
+const modelToolResultSchema = (0, import_ai.jsonSchema)({});
+function createToolDefinitionBase(tool) {
+  return {
+    inputSchema: (0, import_ai.jsonSchema)(tool.parameters),
+    ...tool.description ? { description: tool.description } : {}
+  };
+}
+function createModelToolDefinitions(tools) {
+  const definitions = {};
+  for (const [toolName, tool] of Object.entries(tools)) {
+    definitions[toolName] = {
+      ...createToolDefinitionBase(tool),
+      outputSchema: modelToolResultSchema
+    };
+  }
+  return definitions;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  buildOpenAIReasoningProfile
+  createModelToolDefinitions
 });

package/dist/llm/executor/tool-definitions.d.ts

@@ -0,0 +1,4 @@
+import { type ToolSet as VercelToolSet } from 'ai';
+import type { ToolSet } from '../../tools/types.js';
+export declare function createModelToolDefinitions(tools: ToolSet): VercelToolSet;
+//# sourceMappingURL=tool-definitions.d.ts.map

package/dist/llm/executor/tool-definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-definitions.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/tool-definitions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,OAAO,IAAI,aAAa,EAAE,MAAM,IAAI,CAAC;AAC/D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAWpD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CASxE"}

package/dist/llm/executor/tool-definitions.js

@@ -0,0 +1,22 @@
+import "../../chunk-C6A6W6XS.js";
+import { jsonSchema } from "ai";
+const modelToolResultSchema = jsonSchema({});
+function createToolDefinitionBase(tool) {
+  return {
+    inputSchema: jsonSchema(tool.parameters),
+    ...tool.description ? { description: tool.description } : {}
+  };
+}
+function createModelToolDefinitions(tools) {
+  const definitions = {};
+  for (const [toolName, tool] of Object.entries(tools)) {
+    definitions[toolName] = {
+      ...createToolDefinitionBase(tool),
+      outputSchema: modelToolResultSchema
+    };
+  }
+  return definitions;
+}
+export {
+  createModelToolDefinitions
+};

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

@@ -1,4 +1,4 @@
-import "../../chunk-PTJYTZNU.js";
+import "../../chunk-C6A6W6XS.js";
 const DEFAULT_MAX_TOOL_OUTPUT_CHARS = 12e4;
 const DEFAULT_MAX_FILE_LINES = 2e3;
 const DEFAULT_MAX_LINE_LENGTH = 2e3;