@dexto/core 1.3.0 → 1.4.0

package/dist/llm/services/vercel.cjs

@@ -66,26 +66,20 @@ __export(vercel_exports, {
   VercelLLMService: () => VercelLLMService
 });
 module.exports = __toCommonJS(vercel_exports);
-var import_ai = require("ai");
 var import_types2 = require("../../logger/v2/types.js");
-var import_ai2 = require("ai");
 var import_manager = require("../../context/manager.js");
-var import_utils = require("../../context/utils.js");
-var import_debug = require("../../utils/debug.js");
 var import_registry = require("../registry.js");
-var import_DextoRuntimeError = require("../../errors/DextoRuntimeError.js");
-var import_error_codes = require("../error-codes.js");
-var import_types5 = require("../../errors/types.js");
-var import_error_conversion = require("../../utils/error-conversion.js");
-var import_error_codes2 = require("../../tools/error-codes.js");
 var import_vercel = require("../formatters/vercel.js");
-var import_factory = require("../tokenizer/factory.js");
 var import_decorators = require("../../telemetry/decorators.js");
 var import_api = require("@opentelemetry/api");
+var import_turn_executor = require("../executor/turn-executor.js");
+var import_message_queue = require("../../session/message-queue.js");
+var import_DextoRuntimeError = require("../../errors/DextoRuntimeError.js");
+var import_error_codes = require("../error-codes.js");
 var _VercelLLMService_decorators, _init;
 _VercelLLMService_decorators = [(0, import_decorators.InstrumentClass)({
   prefix: "llm.vercel",
-  excludeMethods: ["getModelId", "getAllTools", "formatTools", "validateToolSupport"]
+  excludeMethods: ["getModelId", "getAllTools", "createTurnExecutor"]
 })];
 class VercelLLMService {
   model;
@@ -94,8 +88,9 @@ class VercelLLMService {
   contextManager;
   sessionEventBus;
   sessionId;
-  toolSupportCache = /* @__PURE__ */ new Map();
   logger;
+  resourceManager;
+  messageQueue;
   /**
    * Helper to extract model ID from LanguageModel union type (string | LanguageModelV2)
    */
@@ -109,20 +104,19 @@ class VercelLLMService {
     this.toolManager = toolManager;
     this.sessionEventBus = sessionEventBus;
     this.sessionId = sessionId;
+    this.resourceManager = resourceManager;
+    this.messageQueue = new import_message_queue.MessageQueueService(this.sessionEventBus, this.logger);
     const formatter = new import_vercel.VercelMessageFormatter(this.logger);
-    const tokenizer = (0, import_factory.createTokenizer)(config.provider, this.getModelId(), this.logger);
     const maxInputTokens = (0, import_registry.getEffectiveMaxInputTokens)(config, this.logger);
     this.contextManager = new import_manager.ContextManager(
       config,
       formatter,
       systemPromptManager,
       maxInputTokens,
-      tokenizer,
       historyProvider,
       sessionId,
       resourceManager,
       this.logger
-      // compressionStrategies uses default
     );
     this.logger.debug(
       `[VercelLLMService] Initialized for model: ${this.getModelId()}, provider: ${this.config.provider}, temperature: ${this.config.temperature}, maxOutputTokens: ${this.config.maxOutputTokens}`
@@ -131,134 +125,40 @@ class VercelLLMService {
   getAllTools() {
     return this.toolManager.getAllTools();
   }
-  formatTools(tools) {
-    this.logger.debug(`Formatting tools for vercel`);
-    return Object.keys(tools).reduce((acc, toolName) => {
-      const tool = tools[toolName];
-      if (tool) {
-        acc[toolName] = {
-          inputSchema: (0, import_ai2.jsonSchema)(tool.parameters),
-          execute: async (args, options) => {
-            const callId = options.toolCallId;
-            try {
-              this.logger.debug(
-                `[vercel] Emitting toolCall event for ${toolName} with callId ${callId}`
-              );
-              this.sessionEventBus.emit("llm:tool-call", {
-                toolName,
-                args,
-                callId
-              });
-              const rawResult = await this.toolManager.executeTool(
-                toolName,
-                args,
-                this.sessionId
-              );
-              const persisted = await this.contextManager.addToolResult(
-                callId,
-                toolName,
-                rawResult,
-                { success: true }
-              );
-              this.logger.debug(
-                `[vercel] Emitting toolResult event for ${toolName} with callId ${callId}`
-              );
-              this.sessionEventBus.emit("llm:tool-result", {
-                toolName,
-                callId,
-                success: true,
-                sanitized: persisted,
-                ...(0, import_debug.shouldIncludeRawToolResult)() ? { rawResult } : {}
-              });
-              const summaryText = (0, import_utils.summarizeToolContentForText)(persisted.content);
-              return summaryText;
-            } catch (err) {
-              let errorResult;
-              let errorFlags = "";
-              if (err instanceof import_DextoRuntimeError.DextoRuntimeError && err.code === import_error_codes2.ToolErrorCode.EXECUTION_DENIED) {
-                errorResult = { error: err.message, denied: true };
-                errorFlags = " (denied)";
-              } else if (err instanceof import_DextoRuntimeError.DextoRuntimeError && err.code === import_error_codes2.ToolErrorCode.CONFIRMATION_TIMEOUT) {
-                errorResult = { error: err.message, denied: true, timeout: true };
-                errorFlags = " (timeout)";
-              } else {
-                const message = err instanceof Error ? err.message : String(err);
-                errorResult = { error: message };
-              }
-              try {
-                const persisted = await this.contextManager.addToolResult(
-                  callId,
-                  toolName,
-                  errorResult,
-                  { success: false }
-                );
-                this.sessionEventBus.emit("llm:tool-result", {
-                  toolName,
-                  callId,
-                  success: false,
-                  sanitized: persisted,
-                  ...(0, import_debug.shouldIncludeRawToolResult)() ? { rawResult: errorResult } : {}
-                });
-              } catch (persistErr) {
-                this.logger.error(
-                  `Failed to persist error result for ${toolName}: ${String(persistErr)}`
-                );
-              }
-              return `Tool ${toolName} failed${errorFlags}: ${errorResult.error}`;
-            }
-          },
-          ...tool.description && { description: tool.description }
-        };
-      }
-      return acc;
-    }, {});
-  }
-  async validateToolSupport() {
-    const modelKey = `${this.config.provider}:${this.getModelId()}:${this.config.baseURL ?? ""}`;
-    if (this.toolSupportCache.has(modelKey)) {
-      return this.toolSupportCache.get(modelKey);
-    }
-    if (!this.config.baseURL) {
-      this.logger.debug(`Skipping tool validation for ${modelKey} - no custom baseURL`);
-      this.toolSupportCache.set(modelKey, true);
-      return true;
-    }
-    this.logger.debug(`Testing tool support for custom endpoint model: ${modelKey}`);
-    const testTool = {
-      test_tool: {
-        inputSchema: (0, import_ai2.jsonSchema)({
-          type: "object",
-          properties: {},
-          additionalProperties: false
-        }),
-        execute: async () => ({ result: "test" })
-      }
-    };
-    try {
-      await (0, import_ai.generateText)({
-        model: this.model,
-        messages: [{ role: "user", content: "Hello" }],
-        tools: testTool,
-        stopWhen: (0, import_ai.stepCountIs)(1)
-      });
-      this.toolSupportCache.set(modelKey, true);
-      this.logger.debug(`Model ${modelKey} supports tools`);
-      return true;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (errorMessage.includes("does not support tools")) {
-        this.toolSupportCache.set(modelKey, false);
-        this.logger.debug(`Model ${modelKey} does not support tools`);
-        return false;
-      }
-      this.logger.debug(
-        `Tool validation error for ${modelKey}, assuming supported: ${errorMessage}`
-      );
-      this.toolSupportCache.set(modelKey, true);
-      return true;
-    }
+  /**
+   * Create a TurnExecutor instance for executing the agent loop.
+   */
+  createTurnExecutor(externalSignal) {
+    return new import_turn_executor.TurnExecutor(
+      this.model,
+      this.toolManager,
+      this.contextManager,
+      this.sessionEventBus,
+      this.resourceManager,
+      this.sessionId,
+      {
+        maxSteps: this.config.maxIterations,
+        maxOutputTokens: this.config.maxOutputTokens,
+        temperature: this.config.temperature,
+        baseURL: this.config.baseURL
+      },
+      { provider: this.config.provider, model: this.getModelId() },
+      this.logger,
+      this.messageQueue,
+      void 0,
+      // modelLimits - TurnExecutor will use defaults
+      externalSignal
+    );
   }
-  async completeTask(textInput, options, imageData, fileData, stream) {
+  /**
+   * Stream a response for the given content.
+   * Primary method for running conversations with multi-image support.
+   *
+   * @param content - String or ContentPart[] (text, images, files)
+   * @param options - { signal?: AbortSignal }
+   * @returns The assistant's text response
+   */
+  async stream(content, options) {
     const activeSpan = import_api.trace.getActiveSpan();
     const currentContext = import_api.context.active();
     const provider = this.config.provider;
@@ -281,330 +181,13 @@ class VercelLLMService {
       import_api.propagation.createBaggage(baggageEntries)
     );
     return await import_api.context.with(updatedContext, async () => {
-      await this.contextManager.addUserMessage(textInput, imageData, fileData);
-      const tools = await this.toolManager.getAllTools();
-      this.logger.silly(
-        `[VercelLLMService] Tools before formatting: ${JSON.stringify(tools, null, 2)}`
-      );
-      const formattedTools = this.formatTools(tools);
-      this.logger.silly(
-        `[VercelLLMService] Formatted tools: ${JSON.stringify(formattedTools, null, 2)}`
-      );
-      let fullResponse = "";
-      this.sessionEventBus.emit("llm:thinking");
-      const prepared = await this.contextManager.getFormattedMessagesWithCompression(
-        { mcpManager: this.toolManager.getMcpManager() },
-        { provider: this.config.provider, model: this.getModelId() }
-      );
-      const formattedMessages = prepared.formattedMessages;
-      const tokensUsed = prepared.tokensUsed;
-      this.logger.silly(
-        `Messages (potentially compressed): ${JSON.stringify(formattedMessages, null, 2)}`
-      );
-      this.logger.silly(`Tools: ${JSON.stringify(formattedTools, null, 2)}`);
-      this.logger.debug(`Estimated tokens being sent to Vercel provider: ${tokensUsed}`);
-      if (stream) {
-        fullResponse = await this.streamText(
-          formattedMessages,
-          formattedTools,
-          this.config.maxIterations,
-          options?.signal
-        );
-      } else {
-        fullResponse = await this.generateText(
-          formattedMessages,
-          formattedTools,
-          this.config.maxIterations,
-          options?.signal
-        );
-      }
-      if (options?.signal?.aborted) {
-        return fullResponse;
-      }
-      return fullResponse || `Reached maximum number of steps (${this.config.maxIterations}) without a final response.`;
-    });
-  }
-  async generateText(messages, tools, maxSteps = 50, signal) {
-    const activeSpan = import_api.trace.getActiveSpan();
-    if (activeSpan) {
-      activeSpan.setAttribute("llm.provider", this.config.provider);
-      activeSpan.setAttribute("llm.model", this.getModelId());
-    }
-    let stepIteration = 0;
-    const estimatedTokens = Math.ceil(JSON.stringify(messages, null, 2).length / 4);
-    this.logger.debug(
-      `vercel generateText:Generating text with messages (${estimatedTokens} estimated tokens)`
-    );
-    const temperature = this.config.temperature;
-    const maxOutputTokens = this.config.maxOutputTokens;
-    const supportsTools = await this.validateToolSupport();
-    const effectiveTools = supportsTools ? tools : {};
-    if (!supportsTools && Object.keys(tools).length > 0) {
-      this.logger.debug(
-        `Model ${this.getModelId()} does not support tools, using empty tools object for generation`
-      );
-    }
-    try {
-      const includeMaxOutputTokens = typeof maxOutputTokens === "number";
-      const response = await (0, import_ai.generateText)({
-        model: this.model,
-        messages,
-        tools: effectiveTools,
-        ...signal ? { abortSignal: signal } : {},
-        onStepFinish: async (step) => {
-          this.logger.debug(`Step iteration: ${stepIteration}`);
-          stepIteration++;
-          this.logger.debug(`Step finished, text: ${step.text}`);
-          this.logger.debug(
-            `Step finished, step tool calls: ${JSON.stringify(step.toolCalls, null, 2)}`
-          );
-          this.logger.debug(
-            `Step finished, step tool results: ${JSON.stringify(step.toolResults, null, 2)}`
-          );
-        },
-        stopWhen: (0, import_ai.stepCountIs)(maxSteps),
-        ...includeMaxOutputTokens ? { maxOutputTokens } : {},
-        ...temperature !== void 0 && { temperature }
-      });
-      this.sessionEventBus.emit("llm:response", {
-        content: response.text,
-        ...response.reasoningText && { reasoning: response.reasoningText },
-        provider: this.config.provider,
-        model: this.getModelId(),
-        router: "vercel",
-        tokenUsage: {
-          ...response.totalUsage.inputTokens !== void 0 && {
-            inputTokens: response.totalUsage.inputTokens
-          },
-          ...response.totalUsage.outputTokens !== void 0 && {
-            outputTokens: response.totalUsage.outputTokens
-          },
-          ...response.totalUsage.reasoningTokens !== void 0 && {
-            reasoningTokens: response.totalUsage.reasoningTokens
-          },
-          ...response.totalUsage.totalTokens !== void 0 && {
-            totalTokens: response.totalUsage.totalTokens
-          }
-        }
-      });
-      const activeSpan2 = import_api.trace.getActiveSpan();
-      if (activeSpan2) {
-        const attributes = {};
-        if (response.totalUsage.inputTokens !== void 0) {
-          attributes["gen_ai.usage.input_tokens"] = response.totalUsage.inputTokens;
-        }
-        if (response.totalUsage.outputTokens !== void 0) {
-          attributes["gen_ai.usage.output_tokens"] = response.totalUsage.outputTokens;
-        }
-        if (response.totalUsage.totalTokens !== void 0) {
-          attributes["gen_ai.usage.total_tokens"] = response.totalUsage.totalTokens;
-        }
-        if (response.totalUsage.reasoningTokens !== void 0) {
-          attributes["gen_ai.usage.reasoning_tokens"] = response.totalUsage.reasoningTokens;
-        }
-        activeSpan2.setAttributes(attributes);
-      }
-      await this.contextManager.processLLMResponse(response);
-      if (typeof response.totalUsage.totalTokens === "number") {
-        this.contextManager.updateActualTokenCount(response.totalUsage.totalTokens);
-      }
-      return response.text;
-    } catch (err) {
-      const error = this.mapProviderError(err, "generate");
-      this.sessionEventBus.emit("llm:error", {
-        error,
-        context: "generateText",
-        recoverable: false
-      });
-      return "";
-    }
-  }
-  mapProviderError(err, phase) {
-    if (import_ai.APICallError.isInstance?.(err)) {
-      this.logger.error(`APICallError in mapProviderError: ${JSON.stringify(err, null, 2)}`);
-      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_types5.ErrorScope.LLM,
-          import_types5.ErrorType.RATE_LIMIT,
-          `Rate limit exceeded${body ? ` - ${body}` : ""}`,
-          {
-            sessionId: this.sessionId,
-            provider: this.config.provider,
-            model: this.getModelId(),
-            status,
-            retryAfter,
-            body,
-            phase
-          }
-        );
-      }
-      if (status === 408) {
-        return new import_DextoRuntimeError.DextoRuntimeError(
-          import_error_codes.LLMErrorCode.GENERATION_FAILED,
-          import_types5.ErrorScope.LLM,
-          import_types5.ErrorType.TIMEOUT,
-          `Provider timed out${body ? ` - ${body}` : ""}`,
-          {
-            sessionId: this.sessionId,
-            provider: this.config.provider,
-            model: this.getModelId(),
-            status,
-            body,
-            phase
-          }
-        );
-      }
-      return new import_DextoRuntimeError.DextoRuntimeError(
-        import_error_codes.LLMErrorCode.GENERATION_FAILED,
-        import_types5.ErrorScope.LLM,
-        import_types5.ErrorType.THIRD_PARTY,
-        `Provider error ${status}${body ? ` - ${body}` : ""}`,
-        {
-          sessionId: this.sessionId,
-          provider: this.config.provider,
-          model: this.getModelId(),
-          status,
-          body,
-          phase
-        }
-      );
-    }
-    return (0, import_error_conversion.toError)(err, this.logger);
-  }
-  // Updated streamText to behave like generateText - returns string and handles message processing internally
-  async streamText(messages, tools, maxSteps = 10, signal) {
-    const activeSpan = import_api.trace.getActiveSpan();
-    if (activeSpan) {
-      activeSpan.setAttribute("llm.provider", this.config.provider);
-      activeSpan.setAttribute("llm.model", this.getModelId());
-    }
-    let stepIteration = 0;
-    const temperature = this.config.temperature;
-    const maxOutputTokens = this.config.maxOutputTokens;
-    const supportsTools = await this.validateToolSupport();
-    const effectiveTools = supportsTools ? tools : {};
-    if (!supportsTools && Object.keys(tools).length > 0) {
-      this.logger.debug(
-        `Model ${this.getModelId()} does not support tools, using empty tools object for streaming`
-      );
-    }
-    let streamErr;
-    const includeMaxOutputTokens = typeof maxOutputTokens === "number";
-    let response;
-    response = (0, import_ai.streamText)({
-      model: this.model,
-      messages,
-      tools: effectiveTools,
-      ...signal ? { abortSignal: signal } : {},
-      onChunk: (chunk) => {
-        this.logger.debug(`Chunk type: ${chunk.chunk.type}`);
-        if (chunk.chunk.type === "text-delta") {
-          this.sessionEventBus.emit("llm:chunk", {
-            chunkType: "text",
-            content: chunk.chunk.text,
-            isComplete: false
-          });
-        } else if (chunk.chunk.type === "reasoning-delta") {
-          this.sessionEventBus.emit("llm:chunk", {
-            chunkType: "reasoning",
-            content: chunk.chunk.text,
-            isComplete: false
-          });
-        }
-      },
-      // TODO: Add onAbort handler when we implement partial response handling.
-      // Vercel triggers onAbort instead of onError for cancelled streams.
-      // This is where cancellation logic should be handled properly.
-      onError: (error) => {
-        const err = this.mapProviderError(error, "stream");
-        this.logger.error(`Error in streamText after parsing: ${err.toString()}`);
-        this.sessionEventBus.emit("llm:error", {
-          error: err,
-          context: "streamText",
-          recoverable: false
-        });
-        streamErr = error;
-      },
-      onStepFinish: async (step) => {
-        this.logger.debug(`Step iteration: ${stepIteration}`);
-        stepIteration++;
-        this.logger.debug(`Step finished, text: ${step.text}`);
-        this.logger.debug(
-          `Step finished, step tool calls: ${JSON.stringify(step.toolCalls, null, 2)}`
-        );
-        this.logger.debug(
-          `Step finished, step tool results: ${JSON.stringify(step.toolResults, null, 2)}`
-        );
-      },
-      // No onFinish: we finalize after the stream completes below.
-      stopWhen: (0, import_ai.stepCountIs)(maxSteps),
-      ...includeMaxOutputTokens ? { maxOutputTokens } : {},
-      ...temperature !== void 0 && { temperature }
+      const parts = typeof content === "string" ? [{ type: "text", text: content }] : content;
+      await this.contextManager.addUserMessage(parts);
+      const executor = this.createTurnExecutor(options?.signal);
+      const contributorContext = { mcpManager: this.toolManager.getMcpManager() };
+      const result = await executor.execute(contributorContext, true);
+      return result.text ?? "";
     });
-    if (streamErr) {
-      return "";
-    }
-    let finalText;
-    let usage;
-    let reasoningText;
-    try {
-      [finalText, usage, reasoningText] = await Promise.all([
-        response.text,
-        response.totalUsage,
-        response.reasoningText
-      ]);
-    } catch (_error) {
-      this.logger.debug(
-        `streamText finalization failed while awaiting text/usage/reasoning: ${String(_error)}`
-      );
-      return "";
-    }
-    this.logger.debug(`streamText finalText: ${finalText}`);
-    this.logger.debug(`streamText usage: ${JSON.stringify(usage, null, 2)}`);
-    this.logger.debug(`streamText reasoningText: ${reasoningText}`);
-    this.sessionEventBus.emit("llm:response", {
-      content: finalText,
-      ...reasoningText && { reasoning: reasoningText },
-      provider: this.config.provider,
-      model: this.getModelId(),
-      router: "vercel",
-      tokenUsage: {
-        ...usage.inputTokens !== void 0 && { inputTokens: usage.inputTokens },
-        ...usage.outputTokens !== void 0 && { outputTokens: usage.outputTokens },
-        ...usage.reasoningTokens !== void 0 && {
-          reasoningTokens: usage.reasoningTokens
-        },
-        ...usage.totalTokens !== void 0 && { totalTokens: usage.totalTokens }
-      }
-    });
-    const activeSpan2 = import_api.trace.getActiveSpan();
-    if (activeSpan2) {
-      const attributes = {};
-      if (usage.inputTokens !== void 0) {
-        attributes["gen_ai.usage.input_tokens"] = usage.inputTokens;
-      }
-      if (usage.outputTokens !== void 0) {
-        attributes["gen_ai.usage.output_tokens"] = usage.outputTokens;
-      }
-      if (usage.totalTokens !== void 0) {
-        attributes["gen_ai.usage.total_tokens"] = usage.totalTokens;
-      }
-      if (usage.reasoningTokens !== void 0) {
-        attributes["gen_ai.usage.reasoning_tokens"] = usage.reasoningTokens;
-      }
-      activeSpan2.setAttributes(attributes);
-    }
-    if (typeof usage.totalTokens === "number") {
-      this.contextManager.updateActualTokenCount(usage.totalTokens);
-    }
-    await this.contextManager.processLLMStreamResponse(response);
-    this.logger.silly(`streamText response object: ${JSON.stringify(response, null, 2)}`);
-    return finalText;
   }
   /**
    * Get configuration information about the LLM service
@@ -616,7 +199,6 @@ class VercelLLMService {
     try {
       modelMaxInputTokens = (0, import_registry.getMaxInputTokensForModel)(
         this.config.provider,
-        // Use our internal provider name
         this.getModelId(),
         this.logger
       );
@@ -631,9 +213,7 @@ class VercelLLMService {
       }
     }
     return {
-      router: "vercel",
       provider: this.config.provider,
-      // Use our internal provider name
       model: this.model,
       configuredMaxInputTokens: configuredMaxTokens,
       modelMaxInputTokens
@@ -645,6 +225,12 @@ class VercelLLMService {
   getContextManager() {
     return this.contextManager;
   }
+  /**
+   * Get the message queue for external access (e.g., queueing messages while busy)
+   */
+  getMessageQueue() {
+    return this.messageQueue;
+  }
 }
 _init = __decoratorStart(null);
 VercelLLMService = __decorateElement(_init, 0, "VercelLLMService", _VercelLLMService_decorators, VercelLLMService);