@iqai/adk 0.0.6 → 0.0.8

package/dist/index.mjs

@@ -19,27 +19,47 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/helpers/debug.ts
-var isDebugEnabled, debugLog;
-var init_debug = __esm({
-  "src/helpers/debug.ts"() {
-    isDebugEnabled = () => {
-      return process.env.NODE_ENV === "development" || process.env.DEBUG === "true";
-    };
-    debugLog = (message, ...args) => {
-      const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
-      if (isDebugEnabled()) {
-        console.log(`[DEBUG] ${time}: ${message}`, ...args);
+// src/helpers/logger.ts
+function isDebugEnabled() {
+  return process.env.NODE_ENV === "development" || process.env.DEBUG === "true";
+}
+var Logger;
+var init_logger = __esm({
+  "src/helpers/logger.ts"() {
+    Logger = class {
+      name;
+      isDebugEnabled = isDebugEnabled();
+      constructor({ name }) {
+        this.name = name;
+      }
+      debug(message, ...args) {
+        const time = (/* @__PURE__ */ new Date()).toISOString();
+        if (this.isDebugEnabled) {
+          console.log(`[${time}] \u{1F41B} [DEBUG] \u2728 [${this.name}] ${message}`, ...args);
+        }
+      }
+      info(message, ...args) {
+        const time = (/* @__PURE__ */ new Date()).toISOString();
+        console.info(`[${time}] \u2139\uFE0F [INFO] \u2728 [${this.name}] ${message}`, ...args);
+      }
+      warn(message, ...args) {
+        const time = (/* @__PURE__ */ new Date()).toISOString();
+        console.warn(`[${time}] \u{1F6A7} [WARN] \u2728 [${this.name}] ${message}`, ...args);
+      }
+      error(message, ...args) {
+        const time = (/* @__PURE__ */ new Date()).toISOString();
+        console.error(`[${time}] \u274C [ERROR] \u2728 [${this.name}] ${message}`, ...args);
       }
     };
   }
 });
 
 // src/tools/base/base-tool.ts
-var BaseTool;
+var logger2, BaseTool;
 var init_base_tool = __esm({
   "src/tools/base/base-tool.ts"() {
-    init_debug();
+    init_logger();
+    logger2 = new Logger({ name: "BaseTool" });
     BaseTool = class {
       /**
        * Name of the tool
@@ -129,8 +149,8 @@ var init_base_tool = __esm({
         while (attempts <= (this.shouldRetryOnFailure ? this.maxRetryAttempts : 0)) {
           try {
             if (attempts > 0) {
-              debugLog(
-                `[BaseTool] Retrying tool ${this.name} (attempt ${attempts} of ${this.maxRetryAttempts})...`
+              logger2.debug(
+                `Retrying tool ${this.name} (attempt ${attempts} of ${this.maxRetryAttempts})...`
               );
               const delay = Math.min(
                 this.baseRetryDelay * 2 ** (attempts - 1) + Math.random() * 1e3,
@@ -475,10 +495,11 @@ var BaseAgent = class {
 };
 
 // src/agents/llm-agent.ts
-init_debug();
+init_logger();
 
 // src/models/llm-registry.ts
-init_debug();
+init_logger();
+var logger = new Logger({ name: "LLMRegistry" });
 var LLMRegistry = class _LLMRegistry {
   /**
    * Map of model name regex to LLM class
@@ -535,7 +556,7 @@ var LLMRegistry = class _LLMRegistry {
    * Logs all registered models for debugging
    */
   static logRegisteredModels() {
-    debugLog(
+    logger.debug(
       "Registered LLM models:",
       [..._LLMRegistry.llmRegistry.entries()].map(([regex]) => regex.toString())
     );
@@ -904,6 +925,7 @@ var Agent = class extends BaseAgent {
    * The minimum relevance score for memory augmentation (0-1)
    */
   memoryRelevanceThreshold;
+  logger = new Logger({ name: "LlmAgent" });
   /**
    * Constructor for Agent
    */
@@ -936,7 +958,7 @@ var Agent = class extends BaseAgent {
    */
   async executeTool(toolCall, context) {
     const { name, arguments: argsString } = toolCall.function;
-    debugLog(`Executing tool: ${name}`);
+    this.logger.debug(`Executing tool: ${name}`);
     const tool = this.findTool(name);
     if (!tool) {
       console.warn(`Tool '${name}' not found`);
@@ -954,7 +976,7 @@ var Agent = class extends BaseAgent {
       toolContext.toolName = name;
       toolContext.toolId = toolCall.id;
       const result = await tool.runAsync(args, toolContext);
-      debugLog(`Tool ${name} execution complete`);
+      this.logger.debug(`Tool ${name} execution complete`);
       return {
         name,
         result: typeof result === "string" ? result : JSON.stringify(result)
@@ -1123,7 +1145,7 @@ ${relevantInfo.join("\n\n")}`
       let stepCount = 0;
       while (stepCount < this.maxToolExecutionSteps) {
         stepCount++;
-        debugLog(`Step ${stepCount}: Thinking...`);
+        this.logger.debug(`Step ${stepCount}: Thinking...`);
         const llmRequest = new LLMRequest({
           messages: context.messages,
           config: {
@@ -1140,7 +1162,9 @@ ${relevantInfo.join("\n\n")}`
           throw new Error("No response from LLM");
         }
         if (currentResponse.tool_calls && currentResponse.tool_calls.length > 0) {
-          debugLog(`Tool calls: ${JSON.stringify(currentResponse.tool_calls)}`);
+          this.logger.debug(
+            `Tool calls: ${JSON.stringify(currentResponse.tool_calls)}`
+          );
           context.addMessage({
             role: "assistant",
             content: currentResponse.content || "",
@@ -1159,7 +1183,7 @@ ${relevantInfo.join("\n\n")}`
             });
           }
         } else {
-          debugLog("[Agent] No tool calls, finishing...");
+          this.logger.debug("No tool calls, finishing...");
           context.addMessage({
             role: "assistant",
             content: currentResponse.content || ""
@@ -1197,7 +1221,7 @@ ${relevantInfo.join("\n\n")}`
     let stepCount = 0;
     let hadToolCalls = false;
     while (stepCount < this.maxToolExecutionSteps) {
-      debugLog(`[Agent] Step ${stepCount}: Thinking...`);
+      this.logger.debug(`Step ${stepCount}: Thinking...`);
       const toolDeclarations = this.tools.map((tool) => tool.getDeclaration()).filter((declaration) => declaration !== null);
       const request = {
         messages: context.messages,
@@ -1226,10 +1250,10 @@ ${relevantInfo.join("\n\n")}`
         function_call: finalResponse.function_call
       });
       if (!hadToolCalls) {
-        debugLog("[Agent] No tool calls, finishing...");
+        this.logger.debug("No tool calls, finishing...");
         break;
       }
-      debugLog(`[Agent] Step ${stepCount + 1}: Executing tools...`);
+      this.logger.debug(`Step ${stepCount + 1}: Executing tools...`);
       stepCount++;
       if (finalResponse.function_call) {
         const toolCall = {
@@ -1246,8 +1270,8 @@ ${relevantInfo.join("\n\n")}`
           content: JSON.stringify(result.result)
         });
       } else if (finalResponse.tool_calls && finalResponse.tool_calls.length > 0) {
-        debugLog(
-          `[Agent] Step ${stepCount + 1}: Executing ${finalResponse.tool_calls.length} tool(s)...`
+        this.logger.debug(
+          `Step ${stepCount + 1}: Executing ${finalResponse.tool_calls.length} tool(s)...`
         );
         context.messages.pop();
         context.addMessage({
@@ -1273,8 +1297,9 @@ ${relevantInfo.join("\n\n")}`
 };
 
 // src/agents/sequential-agent.ts
-init_debug();
+init_logger();
 var SequentialAgent = class extends BaseAgent {
+  logger = new Logger({ name: "SequentialAgent" });
   /**
    * Constructor for SequentialAgent
    */
@@ -1294,8 +1319,8 @@ var SequentialAgent = class extends BaseAgent {
    * Executes sub-agents sequentially, passing output from one to the next
    */
   async run(options) {
-    debugLog(
-      `[SequentialAgent] Running ${this.subAgents.length} sub-agents in sequence`
+    this.logger.debug(
+      `Running ${this.subAgents.length} sub-agents in sequence`
     );
     if (this.subAgents.length === 0) {
       return {
@@ -1312,8 +1337,8 @@ var SequentialAgent = class extends BaseAgent {
     let finalResponse = null;
     for (let i = 0; i < this.subAgents.length; i++) {
       const agent = this.subAgents[i];
-      debugLog(
-        `[SequentialAgent] Running sub-agent ${i + 1}/${this.subAgents.length}: ${agent.name}`
+      this.logger.debug(
+        `Running sub-agent ${i + 1}/${this.subAgents.length}: ${agent.name}`
       );
       try {
         const response = await agent.run({
@@ -1329,10 +1354,7 @@ var SequentialAgent = class extends BaseAgent {
           });
         }
       } catch (error) {
-        console.error(
-          `[SequentialAgent] Error in sub-agent ${agent.name}:`,
-          error
-        );
+        console.error(`Error in sub-agent ${agent.name}:`, error);
         return {
           content: `Error in sub-agent ${agent.name}: ${error instanceof Error ? error.message : String(error)}`,
           role: "assistant",
@@ -1370,8 +1392,8 @@ var SequentialAgent = class extends BaseAgent {
    * Streams responses from each sub-agent in sequence
    */
   async *runStreaming(options) {
-    debugLog(
-      `[SequentialAgent] Streaming ${this.subAgents.length} sub-agents in sequence`
+    this.logger.debug(
+      `Streaming ${this.subAgents.length} sub-agents in sequence`
     );
     if (this.subAgents.length === 0) {
       yield {
@@ -1388,8 +1410,8 @@ var SequentialAgent = class extends BaseAgent {
     const currentMessages = [...options.messages];
     for (let i = 0; i < this.subAgents.length; i++) {
       const agent = this.subAgents[i];
-      debugLog(
-        `[SequentialAgent] Streaming sub-agent ${i + 1}/${this.subAgents.length}: ${agent.name}`
+      this.logger.debug(
+        `Streaming sub-agent ${i + 1}/${this.subAgents.length}: ${agent.name}`
       );
       try {
         const streamGenerator = agent.runStreaming({
@@ -1422,10 +1444,7 @@ var SequentialAgent = class extends BaseAgent {
           });
         }
       } catch (error) {
-        console.error(
-          `[SequentialAgent] Error in streaming sub-agent ${agent.name}:`,
-          error
-        );
+        console.error(`Error in streaming sub-agent ${agent.name}:`, error);
         yield {
           content: `Error in sub-agent ${agent.name}: ${error instanceof Error ? error.message : String(error)}`,
           role: "assistant",
@@ -1443,8 +1462,9 @@ var SequentialAgent = class extends BaseAgent {
 };
 
 // src/agents/parallel-agent.ts
-init_debug();
+init_logger();
 var ParallelAgent = class extends BaseAgent {
+  logger = new Logger({ name: "ParallelAgent" });
   /**
    * Constructor for ParallelAgent
    */
@@ -1464,8 +1484,8 @@ var ParallelAgent = class extends BaseAgent {
    * Executes all sub-agents in parallel
    */
   async run(options) {
-    debugLog(
-      `[ParallelAgent] Running ${this.subAgents.length} sub-agents in parallel`
+    this.logger.debug(
+      `Running ${this.subAgents.length} sub-agents in parallel`
     );
     if (this.subAgents.length === 0) {
       return {
@@ -1478,10 +1498,7 @@ var ParallelAgent = class extends BaseAgent {
         messages: options.messages,
         config: options.config
       }).catch((error) => {
-        console.error(
-          `[ParallelAgent] Error in sub-agent ${agent.name}:`,
-          error
-        );
+        console.error(`Error in sub-agent ${agent.name}:`, error);
         return {
           content: `Error in sub-agent ${agent.name}: ${error instanceof Error ? error.message : String(error)}`,
           role: "assistant"
@@ -1509,8 +1526,8 @@ ${result.content || "No content"}
    * Collects streaming responses from all sub-agents
    */
   async *runStreaming(options) {
-    debugLog(
-      `[ParallelAgent] Streaming ${this.subAgents.length} sub-agents in parallel`
+    this.logger.debug(
+      `Streaming ${this.subAgents.length} sub-agents in parallel`
     );
     if (this.subAgents.length === 0) {
       yield {
@@ -1524,10 +1541,7 @@ ${result.content || "No content"}
         messages: options.messages,
         config: options.config
       }).catch((error) => {
-        console.error(
-          `[ParallelAgent] Error in sub-agent ${agent.name}:`,
-          error
-        );
+        console.error(`Error in sub-agent ${agent.name}:`, error);
         return {
           content: `Error in sub-agent ${agent.name}: ${error instanceof Error ? error.message : String(error)}`,
           role: "assistant"
@@ -1577,7 +1591,7 @@ ${response.content || "No content"}
 };
 
 // src/agents/loop-agent.ts
-init_debug();
+init_logger();
 var LoopAgent = class extends BaseAgent {
   /**
    * Maximum number of iterations to prevent infinite loops
@@ -1591,6 +1605,7 @@ var LoopAgent = class extends BaseAgent {
    * Custom condition check function
    */
   conditionCheck;
+  logger = new Logger({ name: "LoopAgent" });
   /**
    * Constructor for LoopAgent
    */
@@ -1618,19 +1633,19 @@ var LoopAgent = class extends BaseAgent {
    */
   async shouldContinue(response, iterationCount, messages, config) {
     if (iterationCount >= this.maxIterations) {
-      debugLog(
-        `[LoopAgent] Maximum iterations (${this.maxIterations}) reached. Stopping loop.`
+      this.logger.debug(
+        `Maximum iterations (${this.maxIterations}) reached. Stopping loop.`
       );
       return false;
     }
     if (this.conditionCheck) {
       const shouldContinue = await this.conditionCheck(response);
-      debugLog(`[LoopAgent] Custom condition check result: ${shouldContinue}`);
+      this.logger.debug(`Custom condition check result: ${shouldContinue}`);
       return shouldContinue;
     }
     if (this.conditionAgent) {
-      debugLog(
-        `[LoopAgent] Using condition agent ${this.conditionAgent.name} to check loop condition`
+      this.logger.debug(
+        `Using condition agent ${this.conditionAgent.name} to check loop condition`
       );
       const conditionMessages = [
         ...messages,
@@ -1650,12 +1665,12 @@ var LoopAgent = class extends BaseAgent {
         });
         const content = conditionResponse.content?.toLowerCase() || "";
         const shouldContinue = content.includes("yes") && !content.includes("no");
-        debugLog(
-          `[LoopAgent] Condition agent result: ${shouldContinue ? "Continue loop" : "Stop loop"}`
+        this.logger.debug(
+          `Condition agent result: ${shouldContinue ? "Continue loop" : "Stop loop"}`
         );
         return shouldContinue;
       } catch (error) {
-        console.error("[LoopAgent] Error in condition agent:", error);
+        console.error("Error in condition agent:", error);
         return false;
       }
     }
@@ -1666,8 +1681,8 @@ var LoopAgent = class extends BaseAgent {
    * Executes the sub-agent in a loop until the condition is met
    */
   async run(options) {
-    debugLog(
-      `[LoopAgent] Starting loop with max ${this.maxIterations} iterations`
+    this.logger.debug(
+      `Starting loop with max ${this.maxIterations} iterations`
     );
     if (this.subAgents.length === 0) {
       return {
@@ -1682,8 +1697,8 @@ var LoopAgent = class extends BaseAgent {
     let shouldContinueLoop = true;
     while (shouldContinueLoop && iterationCount < this.maxIterations) {
       iterationCount++;
-      debugLog(
-        `[LoopAgent] Running iteration ${iterationCount}/${this.maxIterations}`
+      this.logger.debug(
+        `Running iteration ${iterationCount}/${this.maxIterations}`
       );
       try {
         const response = await subAgent.run({
@@ -1708,10 +1723,7 @@ var LoopAgent = class extends BaseAgent {
           });
         }
       } catch (error) {
-        console.error(
-          `[LoopAgent] Error in loop iteration ${iterationCount}:`,
-          error
-        );
+        console.error(`Error in loop iteration ${iterationCount}:`, error);
         break;
       }
     }
@@ -1732,8 +1744,8 @@ ${lastResponse.content || ""}`,
    * Runs the agent with streaming support
    */
   async *runStreaming(options) {
-    debugLog(
-      `[LoopAgent] Starting loop with max ${this.maxIterations} iterations (streaming)`
+    this.logger.debug(
+      `Starting loop with max ${this.maxIterations} iterations (streaming)`
     );
     if (this.subAgents.length === 0) {
       yield {
@@ -1753,8 +1765,8 @@ ${lastResponse.content || ""}`,
     };
     while (shouldContinueLoop && iterationCount < this.maxIterations) {
       iterationCount++;
-      debugLog(
-        `[LoopAgent] Running iteration ${iterationCount}/${this.maxIterations} (streaming)`
+      this.logger.debug(
+        `Running iteration ${iterationCount}/${this.maxIterations} (streaming)`
       );
       yield {
         content: `Running iteration ${iterationCount}/${this.maxIterations}...`,
@@ -1779,8 +1791,8 @@ ${lastResponse.content || ""}`,
           }
         }
         if (!lastChunk) {
-          debugLog(
-            `[LoopAgent] No complete chunk received from iteration ${iterationCount}`
+          this.logger.debug(
+            `No complete chunk received from iteration ${iterationCount}`
           );
           shouldContinueLoop = false;
           continue;
@@ -1807,8 +1819,8 @@ ${lastResponse.content || ""}`,
           };
         }
       } catch (error) {
-        debugLog(
-          `[LoopAgent] Error in loop iteration ${iterationCount}: ${error instanceof Error ? error.message : String(error)}`
+        this.logger.debug(
+          `Error in loop iteration ${iterationCount}: ${error instanceof Error ? error.message : String(error)}`
         );
         yield {
           content: `Error in loop iteration ${iterationCount}: ${error instanceof Error ? error.message : String(error)}`,
@@ -1825,7 +1837,7 @@ ${lastResponse.content || ""}`,
 };
 
 // src/agents/lang-graph-agent.ts
-init_debug();
+init_logger();
 var LangGraphAgent = class extends BaseAgent {
   /**
    * Graph nodes (agents and their connections)
@@ -1843,6 +1855,7 @@ var LangGraphAgent = class extends BaseAgent {
    * Results from node executions
    */
   results = [];
+  logger = new Logger({ name: "LangGraphAgent" });
   /**
    * Constructor for LangGraphAgent
    */
@@ -1917,15 +1930,13 @@ var LangGraphAgent = class extends BaseAgent {
     for (const targetName of currentNode.targets) {
       const targetNode = this.nodes.get(targetName);
       if (!targetNode) {
-        console.error(`[LangGraphAgent] Target node "${targetName}" not found`);
+        console.error(`Target node "${targetName}" not found`);
         continue;
       }
       if (targetNode.condition) {
         const shouldExecute = await targetNode.condition(result, context);
         if (!shouldExecute) {
-          debugLog(
-            `[LangGraphAgent] Skipping node "${targetName}" due to condition`
-          );
+          this.logger.debug(`Skipping node "${targetName}" due to condition`);
           continue;
         }
       }
@@ -1950,9 +1961,7 @@ var LangGraphAgent = class extends BaseAgent {
     };
     const shouldExecute = await node.condition(mockResponse, mockContext);
     if (!shouldExecute) {
-      debugLog(
-        `[LangGraphAgent] Skipping node "${targetName}" due to condition`
-      );
+      this.logger.debug(`Skipping node "${targetName}" due to condition`);
     }
     return { shouldExecute };
   }
@@ -1965,8 +1974,8 @@ var LangGraphAgent = class extends BaseAgent {
       messages: options.messages,
       config: options.config
     });
-    debugLog(
-      `[LangGraphAgent] Starting graph execution from root node "${this.rootNode}"`
+    this.logger.debug(
+      `Starting graph execution from root node "${this.rootNode}"`
     );
     if (this.nodes.size === 0) {
       return {
@@ -1987,9 +1996,7 @@ var LangGraphAgent = class extends BaseAgent {
     while (nodesToExecute.length > 0 && stepCount < this.maxSteps) {
       stepCount++;
       const { node, messages } = nodesToExecute.shift();
-      debugLog(
-        `[LangGraphAgent] Step ${stepCount}: Executing node "${node.name}"`
-      );
+      this.logger.debug(`Step ${stepCount}: Executing node "${node.name}"`);
       executedNodes.push(node.name);
       try {
         const result = await node.agent.run({
@@ -2037,7 +2044,7 @@ var LangGraphAgent = class extends BaseAgent {
           });
         }
       } catch (error) {
-        console.error(`[LangGraphAgent] Error in node "${node.name}":`, error);
+        console.error(`Error in node "${node.name}":`, error);
         return {
           content: `Error in node "${node.name}": ${error instanceof Error ? error.message : String(error)}`,
           role: "assistant"
@@ -2061,8 +2068,8 @@ var LangGraphAgent = class extends BaseAgent {
       messages: options.messages,
       config: options.config
     });
-    debugLog(
-      `[LangGraphAgent] Starting graph execution from root node "${this.rootNode}" (streaming)`
+    this.logger.debug(
+      `Starting graph execution from root node "${this.rootNode}" (streaming)`
     );
     if (this.nodes.size === 0) {
       yield {
@@ -2090,8 +2097,8 @@ var LangGraphAgent = class extends BaseAgent {
     while (nodesToExecute.length > 0 && stepCount < this.maxSteps) {
       stepCount++;
       const { node, messages } = nodesToExecute.shift();
-      debugLog(
-        `[LangGraphAgent] Step ${stepCount}: Executing node "${node.name}" (streaming)`
+      this.logger.debug(
+        `Step ${stepCount}: Executing node "${node.name}" (streaming)`
       );
       executedNodes.push(node.name);
       try {
@@ -2146,7 +2153,7 @@ Node output: ${this.extractTextContent(result.content)}` : ""}`,
           });
         }
       } catch (error) {
-        console.error(`[LangGraphAgent] Error in node "${node.name}":`, error);
+        console.error(`Error in node "${node.name}":`, error);
         yield {
           content: `Error in node "${node.name}": ${error instanceof Error ? error.message : String(error)}`,
           role: "assistant"
@@ -2206,9 +2213,10 @@ function createFunctionTool(func, options) {
 init_function_utils();
 
 // src/tools/common/google-search.ts
-init_debug();
+init_logger();
 init_base_tool();
 var GoogleSearch = class extends BaseTool {
+  logger = new Logger({ name: "GoogleSearch" });
   /**
    * Constructor for GoogleSearch
    */
@@ -2247,7 +2255,9 @@ var GoogleSearch = class extends BaseTool {
    * This is a simplified implementation that doesn't actually search, just returns mock results
    */
   async runAsync(args, _context) {
-    debugLog(`[GoogleSearch] Executing Google search for: ${args.query}`);
+    this.logger.debug(
+      `[GoogleSearch] Executing Google search for: ${args.query}`
+    );
     return {
       results: [
         {
@@ -2710,9 +2720,10 @@ var UserInteractionTool = class extends BaseTool {
 };
 
 // src/tools/common/exit-loop-tool.ts
-init_debug();
+init_logger();
 init_base_tool();
 var ExitLoopTool = class extends BaseTool {
+  logger = new Logger({ name: "ExitLoopTool" });
   /**
    * Constructor for ExitLoopTool
    */
@@ -2740,7 +2751,7 @@ var ExitLoopTool = class extends BaseTool {
    * Execute the exit loop action
    */
   async runAsync(_args, context) {
-    debugLog("[ExitLoopTool] Executing exit loop tool");
+    this.logger.debug("Executing exit loop tool");
     if (context.actions) {
       context.actions.escalate = true;
     } else {
@@ -2755,9 +2766,10 @@ var ExitLoopTool = class extends BaseTool {
 };
 
 // src/tools/common/get-user-choice-tool.ts
-init_debug();
+init_logger();
 init_base_tool();
 var GetUserChoiceTool = class extends BaseTool {
+  logger = new Logger({ name: "GetUserChoiceTool" });
   /**
    * Constructor for GetUserChoiceTool
    */
@@ -2800,13 +2812,11 @@ var GetUserChoiceTool = class extends BaseTool {
    * and the actual choice will be provided asynchronously
    */
   async runAsync(args, context) {
-    debugLog(
-      `[GetUserChoiceTool] Executing get_user_choice with options: ${args.options.join(
-        ", "
-      )}`
+    this.logger.debug(
+      `Executing get_user_choice with options: ${args.options.join(", ")}`
     );
     if (args.question) {
-      debugLog(`[GetUserChoiceTool] Question: ${args.question}`);
+      this.logger.debug(`Question: ${args.question}`);
     }
     if (context.actions) {
       context.actions.skip_summarization = true;
@@ -2820,9 +2830,10 @@ var GetUserChoiceTool = class extends BaseTool {
 };
 
 // src/tools/common/transfer-to-agent-tool.ts
-init_debug();
+init_logger();
 init_base_tool();
 var TransferToAgentTool = class extends BaseTool {
+  logger = new Logger({ name: "TransferToAgentTool" });
   /**
    * Constructor for TransferToAgentTool
    */
@@ -2855,9 +2866,7 @@ var TransferToAgentTool = class extends BaseTool {
    * Execute the transfer to agent action
    */
   async runAsync(args, context) {
-    debugLog(
-      `[TransferToAgentTool] Executing transfer to agent: ${args.agent_name}`
-    );
+    this.logger.debug(`Executing transfer to agent: ${args.agent_name}`);
     if (context.actions) {
       context.actions.transfer_to_agent = args.agent_name;
     } else {
@@ -2872,9 +2881,10 @@ var TransferToAgentTool = class extends BaseTool {
 };
 
 // src/tools/common/load-memory-tool.ts
-init_debug();
+init_logger();
 init_base_tool();
 var LoadMemoryTool = class extends BaseTool {
+  logger = new Logger({ name: "LoadMemoryTool" });
   /**
    * Constructor for LoadMemoryTool
    */
@@ -2907,9 +2917,7 @@ var LoadMemoryTool = class extends BaseTool {
    * Execute the memory loading action
    */
   async runAsync(args, context) {
-    debugLog(
-      `[LoadMemoryTool] Executing load_memory with query: ${args.query}`
-    );
+    this.logger.debug(`Executing load_memory with query: ${args.query}`);
     if (!context.memoryService) {
       return {
         error: "Memory service is not available",
@@ -2933,9 +2941,18 @@ var LoadMemoryTool = class extends BaseTool {
 };
 
 // src/tools/mcp/client.ts
+init_logger();
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { CreateMessageRequestSchema as CreateMessageRequestSchema2 } from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/mcp/sampling-handler.ts
+init_logger();
+import {
+  CreateMessageRequestSchema,
+  CreateMessageResultSchema
+} from "@modelcontextprotocol/sdk/types.js";
 
 // src/tools/mcp/types.ts
 var McpErrorType = /* @__PURE__ */ ((McpErrorType2) => {
@@ -2944,6 +2961,8 @@ var McpErrorType = /* @__PURE__ */ ((McpErrorType2) => {
   McpErrorType2["RESOURCE_CLOSED_ERROR"] = "resource_closed_error";
   McpErrorType2["TIMEOUT_ERROR"] = "timeout_error";
   McpErrorType2["INVALID_SCHEMA_ERROR"] = "invalid_schema_error";
+  McpErrorType2["SAMPLING_ERROR"] = "SAMPLING_ERROR";
+  McpErrorType2["INVALID_REQUEST_ERROR"] = "INVALID_REQUEST_ERROR";
   return McpErrorType2;
 })(McpErrorType || {});
 var McpError = class extends Error {
@@ -2957,6 +2976,154 @@ var McpError = class extends Error {
   }
 };
 
+// src/tools/mcp/sampling-handler.ts
+var McpSamplingHandler = class {
+  logger = new Logger({ name: "McpSamplingHandler" });
+  adkHandler;
+  constructor(adkHandler) {
+    this.adkHandler = adkHandler;
+  }
+  /**
+   * Handle MCP sampling request and convert between formats
+   */
+  async handleSamplingRequest(request) {
+    try {
+      const validationResult = CreateMessageRequestSchema.safeParse(request);
+      if (!validationResult.success) {
+        this.logger.error(
+          "Invalid MCP sampling request:",
+          validationResult.error
+        );
+        throw new McpError(
+          `Invalid sampling request: ${validationResult.error.message}`,
+          "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
+        );
+      }
+      const mcpParams = request.params;
+      if (!mcpParams.messages || !Array.isArray(mcpParams.messages)) {
+        throw new McpError(
+          "Invalid sampling request: messages array is required",
+          "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
+        );
+      }
+      if (!mcpParams.maxTokens || mcpParams.maxTokens <= 0) {
+        throw new McpError(
+          "Invalid sampling request: maxTokens must be a positive number",
+          "INVALID_REQUEST_ERROR" /* INVALID_REQUEST_ERROR */
+        );
+      }
+      this.logger.debug("Converting MCP request to ADK format");
+      const adkMessages = this.convertMcpMessagesToADK(mcpParams.messages);
+      const adkRequest = {
+        messages: adkMessages,
+        systemPrompt: mcpParams.systemPrompt,
+        modelPreferences: mcpParams.modelPreferences,
+        includeContext: mcpParams.includeContext,
+        temperature: mcpParams.temperature,
+        maxTokens: mcpParams.maxTokens,
+        stopSequences: mcpParams.stopSequences,
+        metadata: mcpParams.metadata
+      };
+      this.logger.debug("Calling ADK sampling handler");
+      const adkResponse = await this.adkHandler(adkRequest);
+      this.logger.debug("Converting ADK response to MCP format");
+      const mcpResponse = this.convertADKResponseToMcp(adkResponse);
+      const responseValidation = CreateMessageResultSchema.safeParse(mcpResponse);
+      if (!responseValidation.success) {
+        this.logger.error(
+          "Invalid MCP response generated:",
+          responseValidation.error
+        );
+        throw new McpError(
+          `Invalid response generated: ${responseValidation.error.message}`,
+          "SAMPLING_ERROR" /* SAMPLING_ERROR */
+        );
+      }
+      return mcpResponse;
+    } catch (error) {
+      this.logger.error("Error handling sampling request:", error);
+      if (error instanceof McpError) {
+        throw error;
+      }
+      throw new McpError(
+        `Sampling request failed: ${error instanceof Error ? error.message : String(error)}`,
+        "SAMPLING_ERROR" /* SAMPLING_ERROR */,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Convert MCP messages to ADK message format
+   */
+  convertMcpMessagesToADK(mcpMessages) {
+    return mcpMessages.map((mcpMessage) => {
+      const adkRole = mcpMessage.role === "assistant" ? "assistant" : "user";
+      let adkContent;
+      if (mcpMessage.content.type === "text") {
+        adkContent = mcpMessage.content.text || "";
+      } else if (mcpMessage.content.type === "image") {
+        const contentParts = [];
+        if (mcpMessage.content.text) {
+          contentParts.push({
+            type: "text",
+            text: mcpMessage.content.text
+          });
+        }
+        if (mcpMessage.content.data) {
+          const mimeType = mcpMessage.content.mimeType || "image/jpeg";
+          const dataUrl = `data:${mimeType};base64,${mcpMessage.content.data}`;
+          contentParts.push({
+            type: "image",
+            image_url: {
+              url: dataUrl
+            }
+          });
+        }
+        adkContent = contentParts.length > 0 ? contentParts : "";
+      } else {
+        this.logger.warn(
+          `Unknown MCP content type: ${mcpMessage.content.type}`
+        );
+        adkContent = mcpMessage.content.text || "";
+      }
+      const adkMessage = {
+        role: adkRole,
+        content: adkContent
+      };
+      this.logger.debug(
+        `Converted MCP message - role: ${mcpMessage.role} -> ${adkRole}, content type: ${mcpMessage.content.type}`
+      );
+      return adkMessage;
+    });
+  }
+  /**
+   * Convert ADK response to MCP response format
+   */
+  convertADKResponseToMcp(adkResponse) {
+    const mcpResponse = {
+      model: adkResponse.model,
+      stopReason: adkResponse.stopReason,
+      role: "assistant",
+      // ADK responses are always from assistant
+      content: {
+        type: "text",
+        text: adkResponse.content || ""
+      }
+    };
+    this.logger.debug(
+      `Converted ADK response - model: ${adkResponse.model}, content length: ${adkResponse.content?.length || 0}`
+    );
+    return mcpResponse;
+  }
+  /**
+   * Update the ADK handler
+   */
+  updateHandler(handler) {
+    this.adkHandler = handler;
+    this.logger.debug("ADK sampling handler updated");
+  }
+};
+
 // src/tools/mcp/utils.ts
 function withRetry(fn, instance, reinitMethod, maxRetries = 1) {
   return async (...args) => {
@@ -2991,6 +3158,8 @@ var McpClientService = class {
   client = null;
   transport = null;
   isClosing = false;
+  mcpSamplingHandler = null;
+  logger = new Logger({ name: "McpClientService" });
   constructor(config) {
     this.config = config;
   }
@@ -3041,6 +3210,7 @@ var McpClientService = class {
       } else {
         await connectPromise;
       }
+      await this.setupSamplingHandler(client);
       if (this.config.debug) {
         console.log("\u2705 MCP client connected successfully");
       }
@@ -3192,10 +3362,67 @@ var McpClientService = class {
   isConnected() {
     return !!this.client && !this.isClosing;
   }
+  async setupSamplingHandler(client) {
+    if (!this.mcpSamplingHandler) {
+      if (this.config.debug) {
+        console.log(
+          "\u26A0\uFE0F No sampling handler provided - sampling requests will be rejected"
+        );
+      }
+      return;
+    }
+    client.setRequestHandler(CreateMessageRequestSchema2, async (request) => {
+      try {
+        this.logger.debug("Received sampling request:", request);
+        const response = await this.mcpSamplingHandler.handleSamplingRequest(request);
+        if (this.config.debug) {
+          console.log("\u2705 Sampling request completed successfully");
+        }
+        return response;
+      } catch (error) {
+        console.error("\u274C Error handling sampling request:", error);
+        if (error instanceof McpError) {
+          throw error;
+        }
+        throw new McpError(
+          `Sampling request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "SAMPLING_ERROR" /* SAMPLING_ERROR */,
+          error instanceof Error ? error : void 0
+        );
+      }
+    });
+    if (this.config.debug) {
+      console.log("\u{1F3AF} Sampling handler registered successfully");
+    }
+  }
+  /**
+   * Set an ADK sampling handler
+   */
+  setSamplingHandler(handler) {
+    this.mcpSamplingHandler = new McpSamplingHandler(handler);
+    if (this.client) {
+      this.setupSamplingHandler(this.client).catch((error) => {
+        console.error("Failed to update sampling handler:", error);
+      });
+    }
+  }
+  /**
+   * Remove the sampling handler
+   */
+  removeSamplingHandler() {
+    this.mcpSamplingHandler = null;
+    if (this.client) {
+      try {
+        this.client.removeRequestHandler?.("sampling/createMessage");
+      } catch (error) {
+        console.error("Failed to remove sampling handler:", error);
+      }
+    }
+  }
 };
 
 // src/tools/mcp/create-tool.ts
-init_debug();
+init_logger();
 init_base_tool();
 
 // src/tools/mcp/schema-conversion.ts
@@ -3398,6 +3625,7 @@ var McpToolAdapter = class extends BaseTool {
   mcpTool;
   client;
   clientService = null;
+  logger = new Logger({ name: "McpToolAdapter" });
   constructor(mcpTool, client) {
     const metadata = mcpTool.metadata || {};
     super({
@@ -3430,10 +3658,7 @@ var McpToolAdapter = class extends BaseTool {
     }
   }
   async runAsync(args, _context) {
-    debugLog(
-      `[McpToolAdapter] Executing MCP tool ${this.name} with args:`,
-      args
-    );
+    this.logger.debug(`Executing MCP tool ${this.name} with args:`, args);
     try {
       if (typeof this.mcpTool.execute === "function") {
         return await this.mcpTool.execute(args);
@@ -3753,11 +3978,11 @@ var BaseLLMConnection = class {
 };
 
 // src/models/anthropic-llm.ts
-init_debug();
+init_logger();
 import axios from "axios";
 
 // src/models/anthropic-llm-connection.ts
-init_debug();
+init_logger();
 var AnthropicLLMConnection = class extends BaseLLMConnection {
   /**
    * Axios instance for API calls
@@ -3785,6 +4010,7 @@ var AnthropicLLMConnection = class extends BaseLLMConnection {
   responseCallback;
   errorCallback;
   endCallback;
+  logger = new Logger({ name: "AnthropicLlmConnection" });
   /**
    * Constructor
    */
@@ -3887,12 +4113,10 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
     if (!content?.length) return [];
     const toolUses = [];
     for (const block of content) {
-      debugLog(
-        `[AnthropicLLMConnection] Processing content block of type: ${block.type}`
-      );
+      this.logger.debug(`Processing content block of type: ${block.type}`);
       if (block.type === "tool_use") {
-        debugLog(
-          "[AnthropicLLMConnection] Found tool_use block:",
+        this.logger.debug(
+          "Found tool_use block:",
           JSON.stringify(block, null, 2)
         );
         toolUses.push({
@@ -3902,12 +4126,10 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
         });
       }
     }
-    debugLog(
-      `[AnthropicLLMConnection] Found ${toolUses.length} tool uses in content`
-    );
+    this.logger.debug(`Found ${toolUses.length} tool uses in content`);
     if (toolUses.length > 0) {
-      debugLog(
-        "[AnthropicLLMConnection] Extracted tool uses:",
+      this.logger.debug(
+        "Extracted tool uses:",
         JSON.stringify(toolUses, null, 2)
       );
     }
@@ -4003,8 +4225,8 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
       }
       const toolUses = this.extractToolUses(apiResponse.content);
       const toolCalls = this.convertToolCalls(toolUses);
-      debugLog(
-        `[AnthropicLLMConnection] - Extracted ${toolUses.length} tool uses in content and converted ${toolCalls?.length || 0} tool calls`
+      this.logger.debug(
+        `- Extracted ${toolUses.length} tool uses in content and converted ${toolCalls?.length || 0} tool calls`
       );
       const llmResponse = new LLMResponse({
         role: "assistant",
@@ -4017,16 +4239,13 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
         content: llmResponse.content?.substring(0, 50) + (llmResponse.content && llmResponse.content.length > 50 ? "..." : ""),
         tool_calls: llmResponse.tool_calls ? `[${llmResponse.tool_calls.length} calls]` : "undefined"
       };
-      debugLog(
-        "[AnthropicLLMConnection] Final LLMResponse object:",
+      this.logger.debug(
+        "Final LLMResponse object:",
         JSON.stringify(logObject, null, 2)
       );
       return llmResponse;
     } catch (error) {
-      debugLog(
-        "[AnthropicLLMConnection] Error sending message to Anthropic:",
-        error
-      );
+      this.logger.debug("Error sending message to Anthropic:", error);
       throw error;
     }
   }
@@ -4046,6 +4265,7 @@ var AnthropicLLM = class extends BaseLLM {
    * Default parameters for requests
    */
   defaultParams;
+  logger = new Logger({ name: "AnthropicLLM" });
   /**
    * Constructor for AnthropicLLM
    */
@@ -4178,12 +4398,10 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
     if (!content?.length) return [];
     const toolUses = [];
     for (const block of content) {
-      debugLog(
-        `[AnthropicLLM] Processing content block of type: ${block.type}`
-      );
+      this.logger.debug(`Processing content block of type: ${block.type}`);
       if (block.type === "tool_use") {
-        debugLog(
-          `[AnthropicLLM] Found tool_use block: ${JSON.stringify(block, null, 2)}`
+        this.logger.debug(
+          `Found tool_use block: ${JSON.stringify(block, null, 2)}`
         );
         toolUses.push({
           id: block.id || "unknown-id",
@@ -4192,8 +4410,8 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
         });
       }
     }
-    debugLog(
-      `[AnthropicLLM] Found ${toolUses.length} tool uses in content`,
+    this.logger.debug(
+      `Found ${toolUses.length} tool uses in content`,
       toolUses
     );
     return toolUses;
@@ -4217,12 +4435,12 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
         },
         responseType: stream ? "stream" : "json"
       });
-      debugLog(
-        `[AnthropicLLM] API Response done with ${response.status}:`,
+      this.logger.debug(
+        `API Response done with ${response.status}:`,
         response.data
       );
-      debugLog(
-        "[AnthropicLLM] API Response content:",
+      this.logger.debug(
+        "API Response content:",
         response.data.content.map((block) => ({ type: block.type }))
       );
       return response.data;
@@ -4250,7 +4468,7 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
         top_p: llmRequest.config.top_p ?? this.defaultParams.top_p,
         tools: tools?.length ? tools : void 0
       };
-      debugLog("[AnthropicLLM] API Request:", {
+      this.logger.debug("API Request:", {
         model: params.model,
         messageCount: params.messages.length,
         systemMessage: params.system ? "present" : "none",
@@ -4260,7 +4478,7 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
         throw new Error("Streaming is not supported in this implementation");
       }
       const response = await this.callAnthropicAPI(params);
-      debugLog("[AnthropicLLM] Full Response Content:", response.content);
+      this.logger.debug("Full Response Content:", response.content);
       let content = "";
       for (const block of response.content) {
         if (block.type === "text") {
@@ -4269,8 +4487,8 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
       }
       const toolUses = this.extractToolUses(response.content);
       const toolCalls = this.convertToolUses(toolUses);
-      debugLog("[AnthropicLLM] Extracted Tool Uses:", toolUses);
-      debugLog("[AnthropicLLM] Converted Tool Calls:", toolCalls);
+      this.logger.debug("Extracted Tool Uses:", toolUses);
+      this.logger.debug("Converted Tool Calls:", toolCalls);
       const llmResponse = new LLMResponse({
         role: "assistant",
         content,
@@ -4282,13 +4500,13 @@ ${typeof message.content === "string" ? message.content : JSON.stringify(message
         content: llmResponse.content?.substring(0, 50) + (llmResponse.content && llmResponse.content.length > 50 ? "..." : ""),
         tool_calls: llmResponse.tool_calls ? `[${llmResponse.tool_calls.length} calls]` : "undefined"
       };
-      debugLog(
-        "[AnthropicLLM] Final LLMResponse object:",
+      this.logger.debug(
+        "Final LLMResponse object:",
         JSON.stringify(logObject, null, 2)
       );
       yield llmResponse;
     } catch (error) {
-      debugLog("[AnthropicLLM] Error:", error);
+      this.logger.debug("Error:", error);
       throw error;
     }
   }
@@ -4683,7 +4901,7 @@ var GoogleLLM = class extends BaseLLM {
 };
 
 // src/models/openai-llm.ts
-init_debug();
+init_logger();
 import OpenAI from "openai";
 
 // src/models/openai-llm-connection.ts
@@ -4943,6 +5161,7 @@ var OpenAILLM = class extends BaseLLM {
    * Default parameters for requests
    */
   defaultParams;
+  logger = new Logger({ name: "OpenAILLM" });
   /**
    * Constructor for OpenAILLM
    */
@@ -5092,8 +5311,8 @@ var OpenAILLM = class extends BaseLLM {
    * Convert OpenAI streaming chunk to LLMResponse
    */
   convertChunk(chunk) {
-    debugLog(
-      `[OpenAILLM]: Converting chunk - delta: ${JSON.stringify(chunk.delta || {})}`
+    this.logger.debug(
+      `Converting chunk - delta: ${JSON.stringify(chunk.delta || {})}`
     );
     const content = chunk.delta?.content;
     const result = new LLMResponse({
@@ -5135,24 +5354,24 @@ var OpenAILLM = class extends BaseLLM {
       presence_penalty: llmRequest.config.presence_penalty ?? this.defaultParams.presence_penalty,
       stream: shouldStream
     };
-    debugLog(
-      `[OpenAILLM] Request parameters - model: ${params.model}, messages: ${params.messages.length}, functions: ${params.tools ? params.tools.length : 0}, streaming: ${shouldStream}`
+    this.logger.debug(
+      `Request parameters - model: ${params.model}, messages: ${params.messages.length}, functions: ${params.tools ? params.tools.length : 0}, streaming: ${shouldStream}`
     );
     if (tools && tools.length > 0) {
       params.tools = tools;
     }
     try {
       if (shouldStream) {
-        debugLog("[OpenAILLM] Starting streaming request");
+        this.logger.debug("Starting streaming request");
         const streamResponse = await this.client.chat.completions.create(params);
         let partialFunctionCall;
         const partialToolCalls = /* @__PURE__ */ new Map();
         let accumulatedContent = "";
         const asyncIterable = streamResponse;
-        debugLog("[OpenAILLM] Stream response received, processing chunks");
+        this.logger.debug("Stream response received, processing chunks");
         for await (const chunk of asyncIterable) {
           if (!chunk.choices || chunk.choices.length === 0) {
-            debugLog("[OpenAILLM] Empty chunk received, skipping");
+            this.logger.debug("Empty chunk received, skipping");
             continue;
           }
           const choice = chunk.choices[0];
@@ -5160,8 +5379,8 @@ var OpenAILLM = class extends BaseLLM {
           if (responseChunk.content !== null) {
             accumulatedContent += responseChunk.content;
           }
-          debugLog(
-            `[OpenAILLM] Chunk received - delta: "${choice.delta?.content || ""}"`,
+          this.logger.debug(
+            `Chunk received - delta: "${choice.delta?.content || ""}"`,
             `responseChunk content: "${responseChunk.content || ""}"`,
             `is_partial: ${responseChunk.is_partial}`,
             `accumulated: "${accumulatedContent.substring(0, 30)}${accumulatedContent.length > 30 ? "..." : ""}"`
@@ -5190,12 +5409,12 @@ var OpenAILLM = class extends BaseLLM {
             }
             responseChunk.tool_calls = Array.from(partialToolCalls.values());
           }
-          debugLog("[OpenAILLM] Yielding chunk to caller");
+          this.logger.debug("Yielding chunk to caller");
           yield responseChunk;
         }
         if (accumulatedContent.length > 0) {
-          debugLog(
-            `[OpenAILLM] Yielding final accumulated content: "${accumulatedContent.substring(0, 30)}${accumulatedContent.length > 30 ? "..." : ""}"`
+          this.logger.debug(
+            `Yielding final accumulated content: "${accumulatedContent.substring(0, 30)}${accumulatedContent.length > 30 ? "..." : ""}"`
           );
           yield new LLMResponse({
             content: accumulatedContent,
@@ -5203,14 +5422,14 @@ var OpenAILLM = class extends BaseLLM {
             is_partial: false
           });
         }
-        debugLog("[OpenAILLM] Finished processing all stream chunks");
+        this.logger.debug("Finished processing all stream chunks");
       } else {
-        debugLog("[OpenAILLM] Making non-streaming request");
+        this.logger.debug("Making non-streaming request");
         const response = await this.client.chat.completions.create(params);
         if (!response.choices || response.choices.length === 0) {
           throw new Error("No response from OpenAI");
         }
-        debugLog("[OpenAILLM] Non-streaming response received");
+        this.logger.debug("Non-streaming response received");
         yield this.convertResponse(response.choices[0]);
       }
     } catch (error) {
@@ -5797,7 +6016,7 @@ var InMemoryMemoryService = class {
 };
 
 // src/memory/persistent-memory-service.ts
-init_debug();
+init_logger();
 import fs2 from "fs";
 import path2 from "path";
 var PersistentMemoryService = class {
@@ -5813,6 +6032,7 @@ var PersistentMemoryService = class {
    * File prefix for memory files
    */
   filePrefix;
+  logger = new Logger({ name: "PersistentMemoryService" });
   /**
    * Constructor for PersistentMemoryService
    */
@@ -5901,7 +6121,7 @@ var PersistentMemoryService = class {
           }
         }
       }
-      debugLog(
+      this.logger.debug(
         `Loaded ${this.inMemoryService.getAllSessions().length} sessions from persistent storage`
       );
     } catch (error) {