@dexto/core 1.2.4 → 1.2.5

package/dist/llm/services/openai.js

@@ -4,7 +4,7 @@ import {
   __runInitializers
 } from "../../chunk-C6A6W6XS.js";
 var _OpenAIService_decorators, _init;
-import { logger } from "../../logger/index.js";
+import { DextoLogComponent } from "../../logger/v2/types.js";
 import { ContextManager } from "../../context/manager.js";
 import { getMaxInputTokensForModel, getEffectiveMaxInputTokens } from "../registry.js";
 import { DextoRuntimeError } from "../../errors/DextoRuntimeError.js";
@@ -13,7 +13,7 @@ import { OpenAIMessageFormatter } from "../formatters/openai.js";
 import { createTokenizer } from "../tokenizer/factory.js";
 import { shouldIncludeRawToolResult } from "../../utils/debug.js";
 import { InstrumentClass } from "../../telemetry/decorators.js";
-import { trace } from "@opentelemetry/api";
+import { trace, context, propagation } from "@opentelemetry/api";
 _OpenAIService_decorators = [InstrumentClass({
   prefix: "llm.openai",
   excludeMethods: ["getAllTools", "formatToolsForOpenAI", "getConfig", "getContextManager"]
@@ -25,15 +25,17 @@ class OpenAIService {
   contextManager;
   sessionEventBus;
   sessionId;
-  constructor(toolManager, openai, systemPromptManager, historyProvider, sessionEventBus, config, sessionId, resourceManager) {
+  logger;
+  constructor(toolManager, openai, systemPromptManager, historyProvider, sessionEventBus, config, sessionId, resourceManager, logger) {
+    this.logger = logger.createChild(DextoLogComponent.LLM);
     this.config = config;
     this.openai = openai;
     this.toolManager = toolManager;
     this.sessionEventBus = sessionEventBus;
     this.sessionId = sessionId;
-    const formatter = new OpenAIMessageFormatter();
-    const tokenizer = createTokenizer(config.provider, config.model);
-    const maxInputTokens = getEffectiveMaxInputTokens(config);
+    const formatter = new OpenAIMessageFormatter(this.logger);
+    const tokenizer = createTokenizer(config.provider, config.model, this.logger);
+    const maxInputTokens = getEffectiveMaxInputTokens(config, this.logger);
     this.contextManager = new ContextManager(
       config,
       formatter,
@@ -42,7 +44,8 @@ class OpenAIService {
       tokenizer,
       historyProvider,
       sessionId,
-      resourceManager
+      resourceManager,
+      this.logger
       // compressionStrategies uses default
     );
   }
@@ -50,222 +53,256 @@ class OpenAIService {
     return this.toolManager.getAllTools();
   }
   async completeTask(textInput, options, imageData, fileData, stream) {
-    await this.contextManager.addUserMessage(textInput, imageData, fileData);
-    const rawTools = await this.toolManager.getAllTools();
-    const formattedTools = this.formatToolsForOpenAI(rawTools);
-    logger.silly(`Formatted tools: ${JSON.stringify(formattedTools, null, 2)}`);
-    this.sessionEventBus.emit("llmservice:thinking");
-    let iterationCount = 0;
-    let totalTokens = 0;
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let reasoningTokens = 0;
-    let fullResponse = "";
-    const context = stream ? "OpenAI streaming API call" : "OpenAI API call";
-    try {
-      while (iterationCount < this.config.maxIterations) {
-        if (options?.signal?.aborted) {
-          throw Object.assign(new Error("Aborted"), {
-            name: "AbortError",
-            aborted: true
-          });
-        }
-        iterationCount++;
-        const { message, usage } = stream ? await this.getAIStreamingResponseWithRetries(formattedTools, options?.signal) : await this.getAIResponseWithRetries(formattedTools, options?.signal);
-        if (usage) {
-          totalTokens += usage.total_tokens ?? 0;
-          inputTokens += usage.prompt_tokens ?? 0;
-          outputTokens += usage.completion_tokens ?? 0;
-          reasoningTokens += usage.completion_tokens_details?.reasoning_tokens ?? 0;
-        }
-        if (!message.tool_calls || message.tool_calls.length === 0) {
-          const responseText = message.content || "";
-          const finalContent = stream ? fullResponse + responseText : responseText;
-          await this.contextManager.addAssistantMessage(finalContent, void 0, {
-            tokenUsage: totalTokens > 0 ? {
-              totalTokens,
-              inputTokens,
-              outputTokens,
-              reasoningTokens
-            } : void 0
-          });
-          if (totalTokens > 0) {
-            this.contextManager.updateActualTokenCount(totalTokens);
-          }
-          this.sessionEventBus.emit("llmservice:response", {
-            content: finalContent,
-            provider: this.config.provider,
-            model: this.config.model,
-            router: "in-built",
-            tokenUsage: { totalTokens, inputTokens, outputTokens, reasoningTokens }
-          });
-          const activeSpan2 = trace.getActiveSpan();
-          if (activeSpan2 && totalTokens > 0) {
-            const attributes = {
-              "gen_ai.usage.total_tokens": totalTokens
-            };
-            if (inputTokens > 0) {
-              attributes["gen_ai.usage.input_tokens"] = inputTokens;
-            }
-            if (outputTokens > 0) {
-              attributes["gen_ai.usage.output_tokens"] = outputTokens;
-            }
-            if (reasoningTokens > 0) {
-              attributes["gen_ai.usage.reasoning_tokens"] = reasoningTokens;
-            }
-            activeSpan2.setAttributes(attributes);
-          }
-          return finalContent;
-        }
-        const functionToolCalls = message.tool_calls.filter(
-          (toolCall) => {
-            logger.debug(`Tool call type received: ${toolCall.type}`);
-            return toolCall.type === "function";
-          }
-        );
-        if (message.tool_calls.length > functionToolCalls.length) {
-          logger.warn(
-            `Filtered out ${message.tool_calls.length - functionToolCalls.length} non-function tool calls`
-          );
-        }
-        await this.contextManager.addAssistantMessage(
-          message.content,
-          functionToolCalls.length > 0 ? functionToolCalls : void 0,
-          {}
-        );
-        if (stream && message.content) {
-          fullResponse += message.content;
-        }
-        for (const toolCall of functionToolCalls) {
+    const activeSpan = trace.getActiveSpan();
+    const currentContext = context.active();
+    const provider = this.config.provider;
+    const model = this.config.model;
+    if (activeSpan) {
+      activeSpan.setAttribute("llm.provider", provider);
+      activeSpan.setAttribute("llm.model", model);
+    }
+    const existingBaggage = propagation.getBaggage(currentContext);
+    const baggageEntries = {};
+    if (existingBaggage) {
+      existingBaggage.getAllEntries().forEach(([key, entry]) => {
+        baggageEntries[key] = entry;
+      });
+    }
+    baggageEntries["llm.provider"] = { value: provider };
+    baggageEntries["llm.model"] = { value: model };
+    const updatedContext = propagation.setBaggage(
+      currentContext,
+      propagation.createBaggage(baggageEntries)
+    );
+    return await context.with(updatedContext, async () => {
+      await this.contextManager.addUserMessage(textInput, imageData, fileData);
+      const rawTools = await this.toolManager.getAllTools();
+      const formattedTools = this.formatToolsForOpenAI(rawTools);
+      this.logger.silly(`Formatted tools: ${JSON.stringify(formattedTools, null, 2)}`);
+      this.sessionEventBus.emit("llm:thinking");
+      let iterationCount = 0;
+      let totalTokens = 0;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      let reasoningTokens = 0;
+      let fullResponse = "";
+      const contextStr = stream ? "OpenAI streaming API call" : "OpenAI API call";
+      try {
+        while (iterationCount < this.config.maxIterations) {
           if (options?.signal?.aborted) {
             throw Object.assign(new Error("Aborted"), {
               name: "AbortError",
               aborted: true
             });
           }
-          logger.debug(`Tool call initiated - Type: ${toolCall.type}`);
-          logger.debug(`Tool call details: ${JSON.stringify(toolCall, null, 2)}`);
-          const toolName = toolCall.function.name;
-          let args = {};
-          try {
-            args = JSON.parse(toolCall.function.arguments);
-          } catch (e) {
-            logger.error(`Error parsing arguments for ${toolName}:`, e);
-            const sanitized = await this.contextManager.addToolResult(
-              toolCall.id,
-              toolName,
-              { error: `Failed to parse arguments: ${e}` },
-              { success: false }
-            );
-            this.sessionEventBus.emit("llmservice:toolResult", {
-              toolName,
-              callId: toolCall.id,
-              success: false,
-              sanitized,
-              ...shouldIncludeRawToolResult() ? { rawResult: { error: `Failed to parse arguments: ${e}` } } : {}
+          iterationCount++;
+          const { message, usage } = stream ? await this.getAIStreamingResponseWithRetries(
+            formattedTools,
+            options?.signal
+          ) : await this.getAIResponseWithRetries(formattedTools, options?.signal);
+          if (usage) {
+            totalTokens += usage.total_tokens ?? 0;
+            inputTokens += usage.prompt_tokens ?? 0;
+            outputTokens += usage.completion_tokens ?? 0;
+            reasoningTokens += usage.completion_tokens_details?.reasoning_tokens ?? 0;
+          }
+          if (!message.tool_calls || message.tool_calls.length === 0) {
+            const responseText = message.content || "";
+            const finalContent = stream ? fullResponse + responseText : responseText;
+            await this.contextManager.addAssistantMessage(finalContent, void 0, {
+              tokenUsage: totalTokens > 0 ? {
+                totalTokens,
+                inputTokens,
+                outputTokens,
+                reasoningTokens
+              } : void 0
             });
-            continue;
+            if (totalTokens > 0) {
+              this.contextManager.updateActualTokenCount(totalTokens);
+            }
+            this.sessionEventBus.emit("llm:response", {
+              content: finalContent,
+              provider: this.config.provider,
+              model: this.config.model,
+              router: "in-built",
+              tokenUsage: { totalTokens, inputTokens, outputTokens, reasoningTokens }
+            });
+            const activeSpan3 = trace.getActiveSpan();
+            if (activeSpan3 && totalTokens > 0) {
+              const attributes = {
+                "gen_ai.usage.total_tokens": totalTokens
+              };
+              if (inputTokens > 0) {
+                attributes["gen_ai.usage.input_tokens"] = inputTokens;
+              }
+              if (outputTokens > 0) {
+                attributes["gen_ai.usage.output_tokens"] = outputTokens;
+              }
+              if (reasoningTokens > 0) {
+                attributes["gen_ai.usage.reasoning_tokens"] = reasoningTokens;
+              }
+              activeSpan3.setAttributes(attributes);
+            }
+            return finalContent;
           }
-          this.sessionEventBus.emit("llmservice:toolCall", {
-            toolName,
-            args,
-            callId: toolCall.id
-          });
-          try {
-            const result = await this.toolManager.executeTool(
-              toolName,
-              args,
-              this.sessionId
-            );
-            const sanitized = await this.contextManager.addToolResult(
-              toolCall.id,
-              toolName,
-              result,
-              { success: true }
+          const functionToolCalls = message.tool_calls.filter(
+            (toolCall) => {
+              this.logger.debug(`Tool call type received: ${toolCall.type}`);
+              return toolCall.type === "function";
+            }
+          );
+          if (message.tool_calls.length > functionToolCalls.length) {
+            this.logger.warn(
+              `Filtered out ${message.tool_calls.length - functionToolCalls.length} non-function tool calls`
             );
-            this.sessionEventBus.emit("llmservice:toolResult", {
-              toolName,
-              callId: toolCall.id,
-              success: true,
-              sanitized,
-              ...shouldIncludeRawToolResult() ? { rawResult: result } : {}
-            });
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error(`Tool execution error for ${toolName}: ${errorMessage}`);
-            const sanitized = await this.contextManager.addToolResult(
-              toolCall.id,
-              toolName,
-              { error: errorMessage },
-              { success: false }
+          }
+          await this.contextManager.addAssistantMessage(
+            message.content,
+            functionToolCalls.length > 0 ? functionToolCalls : void 0,
+            {}
+          );
+          if (stream && message.content) {
+            fullResponse += message.content;
+          }
+          for (const toolCall of functionToolCalls) {
+            if (options?.signal?.aborted) {
+              throw Object.assign(new Error("Aborted"), {
+                name: "AbortError",
+                aborted: true
+              });
+            }
+            this.logger.debug(`Tool call initiated - Type: ${toolCall.type}`);
+            this.logger.debug(
+              `Tool call details: ${JSON.stringify(toolCall, null, 2)}`
             );
-            this.sessionEventBus.emit("llmservice:toolResult", {
+            const toolName = toolCall.function.name;
+            let args = {};
+            try {
+              args = JSON.parse(toolCall.function.arguments);
+            } catch (e) {
+              this.logger.error(`Error parsing arguments for ${toolName}:`, {
+                error: e instanceof Error ? e.message : String(e)
+              });
+              const sanitized = await this.contextManager.addToolResult(
+                toolCall.id,
+                toolName,
+                { error: `Failed to parse arguments: ${e}` },
+                { success: false }
+              );
+              this.sessionEventBus.emit("llm:tool-result", {
+                toolName,
+                callId: toolCall.id,
+                success: false,
+                sanitized,
+                ...shouldIncludeRawToolResult() ? { rawResult: { error: `Failed to parse arguments: ${e}` } } : {}
+              });
+              continue;
+            }
+            this.sessionEventBus.emit("llm:tool-call", {
               toolName,
-              callId: toolCall.id,
-              success: false,
-              sanitized,
-              ...shouldIncludeRawToolResult() ? { rawResult: { error: errorMessage } } : {}
+              args,
+              callId: toolCall.id
             });
+            try {
+              const result = await this.toolManager.executeTool(
+                toolName,
+                args,
+                this.sessionId
+              );
+              const sanitized = await this.contextManager.addToolResult(
+                toolCall.id,
+                toolName,
+                result,
+                { success: true }
+              );
+              this.sessionEventBus.emit("llm:tool-result", {
+                toolName,
+                callId: toolCall.id,
+                success: true,
+                sanitized,
+                ...shouldIncludeRawToolResult() ? { rawResult: result } : {}
+              });
+            } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : String(error);
+              this.logger.error(
+                `Tool execution error for ${toolName}: ${errorMessage}`
+              );
+              const sanitized = await this.contextManager.addToolResult(
+                toolCall.id,
+                toolName,
+                { error: errorMessage },
+                { success: false }
+              );
+              this.sessionEventBus.emit("llm:tool-result", {
+                toolName,
+                callId: toolCall.id,
+                success: false,
+                sanitized,
+                ...shouldIncludeRawToolResult() ? { rawResult: { error: errorMessage } } : {}
+              });
+            }
           }
         }
-      }
-      logger.warn(`Reached maximum iterations (${this.config.maxIterations}) for task.`);
-      const finalResponse = fullResponse || "Task completed but reached maximum tool call iterations.";
-      await this.contextManager.addAssistantMessage(finalResponse, void 0, {
-        tokenUsage: totalTokens > 0 ? {
-          totalTokens,
-          inputTokens,
-          outputTokens,
-          reasoningTokens
-        } : void 0
-      });
-      if (totalTokens > 0) {
-        this.contextManager.updateActualTokenCount(totalTokens);
-      }
-      this.sessionEventBus.emit("llmservice:response", {
-        content: finalResponse,
-        provider: this.config.provider,
-        model: this.config.model,
-        router: "in-built",
-        tokenUsage: { totalTokens, inputTokens, outputTokens, reasoningTokens }
-      });
-      const activeSpan = trace.getActiveSpan();
-      if (activeSpan && totalTokens > 0) {
-        const attributes = {
-          "gen_ai.usage.total_tokens": totalTokens
-        };
-        if (inputTokens > 0) {
-          attributes["gen_ai.usage.input_tokens"] = inputTokens;
+        this.logger.warn(
+          `Reached maximum iterations (${this.config.maxIterations}) for task.`
+        );
+        const finalResponse = fullResponse || "Task completed but reached maximum tool call iterations.";
+        await this.contextManager.addAssistantMessage(finalResponse, void 0, {
+          tokenUsage: totalTokens > 0 ? {
+            totalTokens,
+            inputTokens,
+            outputTokens,
+            reasoningTokens
+          } : void 0
+        });
+        if (totalTokens > 0) {
+          this.contextManager.updateActualTokenCount(totalTokens);
         }
-        if (outputTokens > 0) {
-          attributes["gen_ai.usage.output_tokens"] = outputTokens;
+        this.sessionEventBus.emit("llm:response", {
+          content: finalResponse,
+          provider: this.config.provider,
+          model: this.config.model,
+          router: "in-built",
+          tokenUsage: { totalTokens, inputTokens, outputTokens, reasoningTokens }
+        });
+        const activeSpan2 = trace.getActiveSpan();
+        if (activeSpan2 && totalTokens > 0) {
+          const attributes = {
+            "gen_ai.usage.total_tokens": totalTokens
+          };
+          if (inputTokens > 0) {
+            attributes["gen_ai.usage.input_tokens"] = inputTokens;
+          }
+          if (outputTokens > 0) {
+            attributes["gen_ai.usage.output_tokens"] = outputTokens;
+          }
+          if (reasoningTokens > 0) {
+            attributes["gen_ai.usage.reasoning_tokens"] = reasoningTokens;
+          }
+          activeSpan2.setAttributes(attributes);
         }
-        if (reasoningTokens > 0) {
-          attributes["gen_ai.usage.reasoning_tokens"] = reasoningTokens;
+        return finalResponse;
+      } catch (error) {
+        if (error instanceof Error && (error.name === "AbortError" || error.aborted === true)) {
+          throw error;
         }
-        activeSpan.setAttributes(attributes);
-      }
-      return finalResponse;
-    } catch (error) {
-      if (error instanceof Error && (error.name === "AbortError" || error.aborted === true)) {
-        throw error;
-      }
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error(`Error in ${context}: ${errorMessage}`, { error });
-      if (!stream) {
-        logger.warn(
-          `If this error is due to token overflow, consider configuring 'maxInputTokens' in your LLMConfig.`
-        );
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Error in ${contextStr}: ${errorMessage}`, { error });
+        if (!stream) {
+          this.logger.warn(
+            `If this error is due to token overflow, consider configuring 'maxInputTokens' in your LLMConfig.`
+          );
+        }
+        this.sessionEventBus.emit("llm:error", {
+          error: error instanceof Error ? error : new Error(errorMessage),
+          context: contextStr,
+          recoverable: false
+        });
+        const errorResponse = `Error processing ${stream ? "streaming " : ""}request: ${errorMessage}`;
+        await this.contextManager.addAssistantMessage(errorResponse, void 0, {});
+        return errorResponse;
       }
-      this.sessionEventBus.emit("llmservice:error", {
-        error: error instanceof Error ? error : new Error(errorMessage),
-        context,
-        recoverable: false
-      });
-      const errorResponse = `Error processing ${stream ? "streaming " : ""}request: ${errorMessage}`;
-      await this.contextManager.addAssistantMessage(errorResponse, void 0, {});
-      return errorResponse;
-    }
+    });
   }
   /**
    * Get configuration information about the LLM service
@@ -277,12 +314,13 @@ class OpenAIService {
     try {
       modelMaxInputTokens = getMaxInputTokensForModel(
         this.config.provider,
-        this.config.model
+        this.config.model,
+        this.logger
       );
     } catch (error) {
       if (error instanceof DextoRuntimeError && error.code === LLMErrorCode.MODEL_UNKNOWN) {
         modelMaxInputTokens = configuredMaxInputTokens;
-        logger.debug(
+        this.logger.debug(
           `Could not find model ${this.config.model} in LLM registry to get max tokens. Using configured max tokens: ${configuredMaxInputTokens}.`
         );
       } else {
@@ -301,7 +339,7 @@ class OpenAIService {
   async getAIResponseWithRetries(tools, signal) {
     let attempts = 0;
     const MAX_ATTEMPTS = 3;
-    logger.debug(`Tools size in getAIResponseWithRetries: ${tools.length}`);
+    this.logger.debug(`Tools size in getAIResponseWithRetries: ${tools.length}`);
     while (attempts < MAX_ATTEMPTS) {
       attempts++;
       try {
@@ -313,10 +351,10 @@ class OpenAIService {
           { mcpManager: this.toolManager.getMcpManager() },
           { provider: this.config.provider, model: this.config.model }
         );
-        logger.silly(
+        this.logger.silly(
           `Message history (potentially compressed) in getAIResponseWithRetries: ${JSON.stringify(formattedMessages, null, 2)}`
         );
-        logger.debug(`Estimated tokens being sent to OpenAI: ${tokensUsed}`);
+        this.logger.debug(`Estimated tokens being sent to OpenAI: ${tokensUsed}`);
         const response = await this.openai.chat.completions.create(
           {
             model: this.config.model,
@@ -328,9 +366,8 @@ class OpenAIService {
           },
           signal ? { signal } : void 0
         );
-        logger.silly(
-          "OPENAI CHAT COMPLETION RESPONSE: ",
-          JSON.stringify(response, null, 2)
+        this.logger.silly(
+          `OPENAI CHAT COMPLETION RESPONSE: ${JSON.stringify(response, null, 2)}`
         );
         const message = response.choices[0]?.message;
         if (!message) {
@@ -343,17 +380,17 @@ class OpenAIService {
           throw error;
         }
         const apiError = error;
-        logger.error(
+        this.logger.error(
           `Error in OpenAI API call (Attempt ${attempts}/${MAX_ATTEMPTS}): ${apiError.message || JSON.stringify(apiError, null, 2)}`,
           { status: apiError.status, headers: apiError.headers }
         );
         if (apiError.status === 400 && apiError.code === "context_length_exceeded") {
-          logger.warn(
+          this.logger.warn(
             `Context length exceeded. ContextManager compression might not be sufficient. Error details: ${JSON.stringify(apiError.error)}`
           );
         }
         if (attempts >= MAX_ATTEMPTS) {
-          logger.error(
+          this.logger.error(
             `Failed to get response from OpenAI after ${MAX_ATTEMPTS} attempts.`
           );
           throw error;
@@ -377,10 +414,10 @@ class OpenAIService {
           { mcpManager: this.toolManager.getMcpManager() },
           { provider: this.config.provider, model: this.config.model }
         );
-        logger.silly(
+        this.logger.silly(
           `Streaming message history (potentially compressed): ${JSON.stringify(formattedMessages, null, 2)}`
         );
-        logger.debug(`Estimated tokens being sent to OpenAI streaming: ${tokensUsed}`);
+        this.logger.debug(`Estimated tokens being sent to OpenAI streaming: ${tokensUsed}`);
         const stream = await this.openai.chat.completions.create(
           {
             model: this.config.model,
@@ -409,8 +446,8 @@ class OpenAIService {
           const delta = chunk.choices[0]?.delta;
           if (delta?.content) {
             content += delta.content;
-            this.sessionEventBus.emit("llmservice:chunk", {
-              type: "text",
+            this.sessionEventBus.emit("llm:chunk", {
+              chunkType: "text",
               content: delta.content,
               isComplete: false
             });
@@ -447,8 +484,8 @@ class OpenAIService {
           }
         }
         if (content) {
-          this.sessionEventBus.emit("llmservice:chunk", {
-            type: "text",
+          this.sessionEventBus.emit("llm:chunk", {
+            chunkType: "text",
             content: "",
             isComplete: true
           });
@@ -459,21 +496,21 @@ class OpenAIService {
           refusal: null,
           ...toolCalls.length > 0 && { tool_calls: toolCalls }
         };
-        logger.debug(`OpenAI streaming completed. Usage info: ${usage}`);
+        this.logger.debug(`OpenAI streaming completed. Usage info: ${usage}`);
         return { message, ...usage && { usage } };
       } catch (error) {
         const apiError = error;
-        logger.error(
+        this.logger.error(
           `Error in OpenAI streaming API call (Attempt ${attempts}/${MAX_ATTEMPTS}): ${apiError.message || JSON.stringify(apiError, null, 2)}`,
           { status: apiError.status, headers: apiError.headers }
         );
         if (apiError.status === 400 && apiError.message?.includes("maximum context length")) {
-          logger.warn(
+          this.logger.warn(
             `Context length exceeded in streaming. ContextManager compression might not be sufficient. Error details: ${JSON.stringify(apiError.error)}`
           );
         }
         if (attempts >= MAX_ATTEMPTS) {
-          logger.error(
+          this.logger.error(
             `Failed to get streaming response from OpenAI after ${MAX_ATTEMPTS} attempts.`
           );
           throw error;