@dainprotocol/service-sdk 2.0.46 → 2.0.48-beta.0

package/dist/service/server.js

@@ -9,7 +9,6 @@ const cors_1 = require("hono/cors");
 const http_exception_1 = require("hono/http-exception");
 const auth_1 = require("./auth");
 const schemaStructure_1 = require("../lib/schemaStructure");
-const zod_1 = require("zod");
 const oauth2_1 = require("./oauth2");
 const bs58_1 = tslib_1.__importDefault(require("bs58"));
 const processes_1 = require("./processes");
@@ -20,7 +19,19 @@ const ed25519_1 = require("@noble/curves/ed25519");
 const sha256_1 = require("@noble/hashes/sha256");
 const utils_1 = require("@noble/hashes/utils");
 const auth_2 = require("./auth");
-console.log("OAuth2 package version:", package_json_1.default.dependencies["@dainprotocol/oauth2-token-manager"]);
+const core_1 = require("./core");
+const VERBOSE_SERVICE_LOGS = process.env.DAIN_VERBOSE_SERVICE_LOGS === "true";
+const debugLog = (...args) => {
+    if (VERBOSE_SERVICE_LOGS) {
+        console.log(...args);
+    }
+};
+const debugWarn = (...args) => {
+    if (VERBOSE_SERVICE_LOGS) {
+        console.warn(...args);
+    }
+};
+debugLog("OAuth2 package version:", package_json_1.default.dependencies["@dainprotocol/oauth2-token-manager"]);
 /**
  * Middleware factory to require specific OAuth scopes
  * Defense-in-depth: Validates scopes even though JWT middleware already checked them
@@ -176,15 +187,19 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
     });
     // Dual Authentication: JWT (users) or API Key (services)
     app.use("*", async (c, next) => {
+        debugLog(`[Auth Middleware] Path: ${c.req.path}, Method: ${c.req.method}`);
         if (c.req.path.startsWith("/oauth2/callback/") ||
             c.req.path.startsWith("/addons") ||
             c.req.path.startsWith("/metadata") ||
             c.req.path.startsWith("/ping")) {
+            debugLog(`[Auth Middleware] Path ${c.req.path} - SKIPPING auth`);
             await next();
             return;
         }
+        debugLog(`[Auth Middleware] Path ${c.req.path} - REQUIRES auth`);
         const jwtToken = (0, auth_1.extractBearerToken)(c.req.header("Authorization"));
         const apiKey = c.req.header("X-DAIN-API-KEY");
+        debugLog(`[Auth Middleware] JWT present: ${!!jwtToken}, API Key present: ${!!apiKey}`);
         if (jwtToken) {
             // JWT Authentication (Users)
             // Auto-detect JWT audience from Host header (works with localhost, tunnels, production)
@@ -220,17 +235,20 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
             c.set('scope', result.scope);
             c.set('jwtPayload', result.payload);
             c.set('smartAccountPDA', c.req.header("X-DAIN-SMART-ACCOUNT-PDA"));
+            debugLog(`[Auth Middleware] JWT auth SUCCESS - smartAccountId: ${result.smartAccountId}`);
         }
         else if (apiKey) {
             // API Key Authentication (Services/Agents)
             const parsed = (0, auth_1.parseAPIKey)(apiKey);
             if (!parsed) {
+                debugLog(`[Auth Middleware] API Key auth FAILED - invalid format`);
                 throw new http_exception_1.HTTPException(401, { message: "Invalid API key format" });
             }
             // Validate API key with platform (skip in dev mode if no platform URL)
             if (config.platformBaseUrl) {
                 const isValid = await (0, auth_1.validateAPIKeyWithPlatform)(apiKey, config.platformBaseUrl);
                 if (!isValid) {
+                    debugLog(`[Auth Middleware] API Key auth FAILED - invalid with platform`);
                     throw new http_exception_1.HTTPException(401, { message: "Invalid API key" });
                 }
             }
@@ -239,34 +257,46 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
             c.set('orgId', parsed.orgId);
             c.set('address', parsed.agentId); // Use agentId as address for API key auth
             c.set('smartAccountPDA', c.req.header("X-DAIN-SMART-ACCOUNT-PDA"));
+            debugLog(`[Auth Middleware] API Key auth SUCCESS - agentId: ${parsed.agentId}, orgId: ${parsed.orgId}`);
         }
         else {
+            debugLog(`[Auth Middleware] Auth FAILED - no JWT or API key provided`);
             throw new http_exception_1.HTTPException(401, { message: "No authentication provided" });
         }
         await next();
     });
     async function getAgentInfo(c) {
+        debugLog("[getAgentInfo] START");
+        debugLog("[getAgentInfo] Auth method:", c.get('authMethod'));
         const smartAccountPDA = c.get('smartAccountPDA') || c.req.header("X-DAIN-SMART-ACCOUNT-PDA");
         const webhookUrl = c.req.header("X-DAIN-WEBHOOK-URL");
+        debugLog("[getAgentInfo] smartAccountPDA:", smartAccountPDA);
+        debugLog("[getAgentInfo] webhookUrl:", webhookUrl);
         if (c.get('authMethod') === 'jwt') {
             const smartAccountId = c.get('smartAccountId');
-            return {
+            debugLog("[getAgentInfo] JWT auth - smartAccountId:", smartAccountId);
+            const agentInfo = {
                 agentId: smartAccountId,
                 address: smartAccountId,
                 smartAccountPDA,
                 id: smartAccountPDA ? `dain_id_${smartAccountPDA}` : `smart_account_${smartAccountId}`,
                 webhookUrl,
             };
+            debugLog("[getAgentInfo] JWT - Returning agent info:", agentInfo);
+            return agentInfo;
         }
         const agentId = c.get('agentId');
         const address = c.get('address');
-        return {
+        debugLog("[getAgentInfo] API Key auth - agentId:", agentId, "address:", address);
+        const agentInfo = {
             agentId,
             address,
             smartAccountPDA,
             id: smartAccountPDA ? `dain_id_${smartAccountPDA}` : `address_${address}`,
             webhookUrl,
         };
+        debugLog("[getAgentInfo] API Key - Returning agent info:", agentInfo);
+        return agentInfo;
     }
     // Setup default ping route
     app.get("/ping", (c) => c.json({ message: "pong", platform: "DAIN", service_version: metadata.version, dain_sdk_version: package_json_1.default.version }));
@@ -663,8 +693,8 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
             prompt: agent.prompt,
             resolveCondition: agent.resolveCondition,
             serviceConnections: agent.serviceConnections || [process.env.BASE_URL || 'http://localhost:3000'],
-            inputSchema: (0, zod_1.toJSONSchema)(agent.input, { unrepresentable: "any" }),
-            outputSchema: (0, zod_1.toJSONSchema)(agent.output, { unrepresentable: "any" }),
+            inputSchema: z.toJSONSchema(agent.input, { unrepresentable: "any" }),
+            outputSchema: z.toJSONSchema(agent.output, { unrepresentable: "any" }),
         }));
         return c.json(agentInfo);
     });
@@ -688,8 +718,8 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
             prompt: agent.prompt,
             resolveCondition: agent.resolveCondition,
             serviceConnections: agent.serviceConnections || [process.env.BASE_URL || 'http://localhost:3000'],
-            inputSchema: (0, zod_1.toJSONSchema)(agent.input, { unrepresentable: "any" }),
-            outputSchema: (0, zod_1.toJSONSchema)(agent.output, { unrepresentable: "any" }),
+            inputSchema: z.toJSONSchema(agent.input, { unrepresentable: "any" }),
+            outputSchema: z.toJSONSchema(agent.output, { unrepresentable: "any" }),
         }));
         // Process plugins for the response
         const processedResponse = await processPluginsForResponse(agentsInfo, body, { extraData: { plugins: processedPluginData.plugins } });
@@ -706,8 +736,8 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
                 prompt: agent.prompt,
                 resolveCondition: agent.resolveCondition,
                 serviceConnections: agent.serviceConnections || [process.env.BASE_URL || 'http://localhost:3000'],
-                inputSchema: (0, zod_1.toJSONSchema)(agent.input, { unrepresentable: "any" }),
-                outputSchema: (0, zod_1.toJSONSchema)(agent.output, { unrepresentable: "any" }),
+                inputSchema: z.toJSONSchema(agent.input, { unrepresentable: "any" }),
+                outputSchema: z.toJSONSchema(agent.output, { unrepresentable: "any" }),
             };
             return c.json(agentDetails);
         }
@@ -737,8 +767,8 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
                 prompt: agent.prompt,
                 resolveCondition: agent.resolveCondition,
                 serviceConnections: agent.serviceConnections || [process.env.BASE_URL || 'http://localhost:3000'],
-                inputSchema: (0, zod_1.toJSONSchema)(agent.input, { unrepresentable: "any" }),
-                outputSchema: (0, zod_1.toJSONSchema)(agent.output, { unrepresentable: "any" }),
+                inputSchema: z.toJSONSchema(agent.input, { unrepresentable: "any" }),
+                outputSchema: z.toJSONSchema(agent.output, { unrepresentable: "any" }),
             };
             // Process plugins for the response
             const processedResponse = await processPluginsForResponse(agentDetails, body, { extraData: { plugins: processedPluginData.plugins } });
@@ -749,15 +779,25 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
         }
     });
     app.get("/getAllToolsAsJsonSchema", (c) => {
-        const toolInfo = tools.map((tool) => ({
-            id: tool.id,
-            name: tool.name,
-            description: tool.description,
-            inputSchema: (0, zod_1.toJSONSchema)(tool.input, { unrepresentable: "any" }),
-            outputSchema: (0, zod_1.toJSONSchema)(tool.output, { unrepresentable: "any" }),
-            interface: tool.interface,
-            suggestConfirmation: tool.suggestConfirmation,
-        }));
+        const toolInfo = tools.map((tool) => {
+            const inputSchema = z.toJSONSchema(tool.input, { unrepresentable: "any" });
+            // Log to file for debugging
+            try {
+                const fs = require('fs');
+                fs.appendFileSync('/tmp/dain-sdk-schemas.log', `\n\n=== Tool: ${tool.id} ===\n` +
+                    JSON.stringify(inputSchema, null, 2) + '\n');
+            }
+            catch (e) { }
+            return {
+                id: tool.id,
+                name: tool.name,
+                description: tool.description,
+                inputSchema: inputSchema,
+                outputSchema: z.toJSONSchema(tool.output, { unrepresentable: "any" }),
+                interface: tool.interface,
+                suggestConfirmation: tool.suggestConfirmation,
+            };
+        });
         return c.json({
             tools: toolInfo,
             reccomendedPrompts: toolboxes.map((toolbox) => toolbox.recommendedPrompt),
@@ -780,8 +820,8 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
             id: tool.id,
             name: tool.name,
             description: tool.description,
-            inputSchema: (0, zod_1.toJSONSchema)(tool.input, { unrepresentable: "any" }),
-            outputSchema: (0, zod_1.toJSONSchema)(tool.output, { unrepresentable: "any" }),
+            inputSchema: z.toJSONSchema(tool.input, { unrepresentable: "any" }),
+            outputSchema: z.toJSONSchema(tool.output, { unrepresentable: "any" }),
             interface: tool.interface,
             suggestConfirmation: tool.suggestConfirmation,
         }));
@@ -868,10 +908,26 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
             throw new Error("config.oauth2.baseUrl is required for OAuth2");
         }
         const oauth2Handler = new oauth2_1.OAuth2Handler(bs58_1.default.encode(privateKey), config.oauth2.baseUrl, config.oauth2.tokenStore);
-        // Register providers
-        Object.entries(config.oauth2.providers).forEach(([name, providerConfig]) => {
-            oauth2Handler.registerProvider(name, providerConfig);
+        // Auto-generate service slug from metadata title
+        const serviceSlug = (0, core_1.toSlug)(metadata.title);
+        // Register providers and auto-create OAuth tools
+        const autoOAuth2Tools = [];
+        Object.entries(config.oauth2.providers).forEach(([providerName, providerConfig]) => {
+            oauth2Handler.registerProvider(providerName, providerConfig);
+            // Auto-create OAuth tool for this provider
+            debugLog(`[OAuth Auto-Registration] Creating OAuth tool: oauth2-${serviceSlug}-${providerName}`);
+            const oauthTool = (0, core_1.createOAuth2Tool)(providerName, serviceSlug, {
+                logoUrl: providerConfig.logoUrl,
+                reason: providerConfig.reason,
+                requiredTools: providerConfig.requiredTools
+            });
+            autoOAuth2Tools.push(oauthTool);
         });
+        // Inject auto-created OAuth tools into the tools array
+        if (autoOAuth2Tools.length > 0) {
+            debugLog(`[OAuth Auto-Registration] Injecting ${autoOAuth2Tools.length} OAuth tool(s) into tools array`);
+            tools.push(...autoOAuth2Tools);
+        }
         // OAuth callback route
         app.get("/oauth2/callback/:provider", async (c) => {
             if (!app.oauth2) {
@@ -950,16 +1006,38 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
     });
     // Get auth URL for specific provider
     app.get("/oauth2/connect/:provider", async (c) => {
+        debugLog("[OAuth2 Connect] Route hit - START");
+        debugLog("[OAuth2 Connect] Provider param:", c.req.param("provider"));
+        debugLog("[OAuth2 Connect] Auth method:", c.get('authMethod'));
+        debugLog("[OAuth2 Connect] Headers:", {
+            authorization: c.req.header("Authorization"),
+            apiKey: c.req.header("X-DAIN-API-KEY"),
+            host: c.req.header("host"),
+        });
         if (!app.oauth2) {
+            debugLog("[OAuth2 Connect] ERROR: OAuth2 not configured");
             throw new http_exception_1.HTTPException(404, { message: "OAuth2 not configured" });
         }
         const provider = c.req.param("provider");
-        const agentInfo = await getAgentInfo(c);
+        debugLog("[OAuth2 Connect] Getting agent info...");
+        let agentInfo;
         try {
+            agentInfo = await getAgentInfo(c);
+            debugLog("[OAuth2 Connect] Agent info retrieved:", agentInfo);
+        }
+        catch (error) {
+            debugLog("[OAuth2 Connect] ERROR getting agent info:", error);
+            throw error;
+        }
+        try {
+            debugLog("[OAuth2 Connect] Generating auth URL for provider:", provider, "for agent:", agentInfo.id);
+            debugLog("[OAuth2 Connect] OAuth2 configured:", !!app.oauth2);
             const authUrl = await app.oauth2.generateAuthUrl(provider, agentInfo.id);
+            debugLog("[OAuth2 Connect] Auth URL generated successfully:", authUrl);
             return c.json({ authUrl });
         }
         catch (error) {
+            debugLog("[OAuth2 Connect] ERROR generating auth URL:", error);
             throw new http_exception_1.HTTPException(400, {
                 message: `Invalid provider: ${provider}`
             });
@@ -974,14 +1052,14 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
             throw new http_exception_1.HTTPException(404, { message: "Process not found" });
         }
         if (process.agentId !== agentInfo.id) {
-            console.log("Unauthorized access to process", process.agentId, agentInfo.id);
+            debugLog("Unauthorized access to process", process.agentId, agentInfo.id);
             throw new http_exception_1.HTTPException(403, { message: "Unauthorized access to process" });
         }
         return c.json(process.humanActions);
     });
     // Get specific human action
     app.get("/processes/:processId/human-actions/:stepId", async (c) => {
-        console.log('GET human action request:', c.req.path);
+        debugLog('GET human action request:', c.req.path);
         const processId = c.req.param("processId");
         const stepId = c.req.param("stepId");
         const agentInfo = await getAgentInfo(c);
@@ -990,7 +1068,7 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
             throw new http_exception_1.HTTPException(404, { message: "Process not found" });
         }
         if (process.agentId !== agentInfo.id) {
-            console.log("Unauthorized access to process", process.agentId, agentInfo.id);
+            debugLog("Unauthorized access to process", process.agentId, agentInfo.id);
             throw new http_exception_1.HTTPException(403, { message: "Unauthorized access to process" });
         }
         const step = await app.processes.checkHumanAction(processId, stepId);
@@ -1009,7 +1087,7 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
             throw new http_exception_1.HTTPException(404, { message: "Process not found" });
         }
         if (process.agentId !== agentInfo.id) {
-            console.log("Unauthorized access to process", process.agentId, agentInfo.id);
+            debugLog("Unauthorized access to process", process.agentId, agentInfo.id);
             throw new http_exception_1.HTTPException(403, { message: "Unauthorized access to process" });
         }
         const body = await c.req.json();
@@ -1126,11 +1204,11 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
         const executeToolWithStreaming = async (c, tool, body, agentInfo, pluginsData, withContext = false) => {
             const wantsStream = c.req.header("Accept") === "text/event-stream";
             if (wantsStream) {
-                console.log(`[SSE] Tool ${tool.id} requested with streaming, params:`, Object.keys(body));
+                debugLog(`[SSE] Tool ${tool.id} requested with streaming, params:`, Object.keys(body));
                 return signedStreamSSE(c, privateKey, config, async (stream) => {
                     try {
                         // Execute the tool first
-                        console.log(`[SSE] Executing tool ${tool.id} in streaming mode${withContext ? ' with context' : ''}`);
+                        debugLog(`[SSE] Executing tool ${tool.id} in streaming mode${withContext ? ' with context' : ''}`);
                         const result = await tool.handler({ ...body, DAIN_EXTRA_DATA: undefined }, agentInfo, {
                             app,
                             oauth2Client: app.oauth2 ? app.oauth2.getClient() : undefined,
@@ -1175,7 +1253,7 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
                         // If we need to include context data
                         let response = result;
                         if (withContext) {
-                            console.log(`Tool ${tool.id} execution completed, gathering contexts`);
+                            debugLog(`Tool ${tool.id} execution completed, gathering contexts`);
                             // Gather contexts with proper error handling
                             let contextsNow = [];
                             try {
@@ -1219,7 +1297,7 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
                                 // Continue with empty contexts rather than failing completely
                                 contextsNow = [];
                             }
-                            console.log(`Gathered ${contextsNow.length} contexts, sending final result`);
+                            debugLog(`Gathered ${contextsNow.length} contexts, sending final result`);
                             // Create the complete response with context
                             response = {
                                 toolResult: result,
@@ -1234,14 +1312,14 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
                             }
                         });
                         // Send the final result
-                        console.log(`[SSE] Sending final ${withContext ? 'context ' : ''}result for ${tool.id}`);
-                        console.log(`[SSE] Result preview:`, JSON.stringify(processedResult).substring(0, 200));
+                        debugLog(`[SSE] Sending final ${withContext ? 'context ' : ''}result for ${tool.id}`);
+                        debugLog(`[SSE] Result preview:`, JSON.stringify(processedResult).substring(0, 200));
                         await stream.writeSSE({
                             event: 'result',
                             data: JSON.stringify(processedResult),
                             id: Date.now().toString(),
                         });
-                        console.log(`[SSE] Final result sent for ${tool.id}`);
+                        debugLog(`[SSE] Final result sent for ${tool.id}`);
                     }
                     catch (error) {
                         console.error(`Error in stream for ${tool.id}:`, error);
@@ -1388,35 +1466,75 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
         };
         // Standard tool execution endpoint
         app.post(`/tools/${tool.id}`, async (c) => {
+            debugLog(`[Tool ${tool.id}] ========== TOOL EXECUTION START ==========`);
+            debugLog(`[Tool ${tool.id}] Path: ${c.req.path}`);
+            debugLog(`[Tool ${tool.id}] Method: ${c.req.method}`);
+            debugLog(`[Tool ${tool.id}] Auth Method: ${c.get('authMethod')}`);
+            debugLog(`[Tool ${tool.id}] Headers:`, {
+                authorization: c.req.header("Authorization") ? "Bearer ***" : undefined,
+                apiKey: c.req.header("X-DAIN-API-KEY") ? "***" : undefined,
+                smartAccountPDA: c.req.header("X-DAIN-SMART-ACCOUNT-PDA"),
+                webhookUrl: c.req.header("X-DAIN-WEBHOOK-URL"),
+            });
             try {
+                debugLog(`[Tool ${tool.id}] Getting agent info...`);
                 const agentInfo = await getAgentInfo(c);
+                debugLog(`[Tool ${tool.id}] Agent info:`, agentInfo);
+                debugLog(`[Tool ${tool.id}] Parsing request body...`);
                 let body = await c.req.json();
+                debugLog(`[Tool ${tool.id}] Request body keys:`, Object.keys(body));
+                debugLog(`[Tool ${tool.id}] Request body:`, JSON.stringify(body, null, 2));
                 // Process plugins for the request
+                debugLog(`[Tool ${tool.id}] Processing plugins...`);
                 body = await processPluginsForRequest(body, agentInfo);
                 // Extract plugins data for the tool context
                 const pluginsData = body.plugins || {};
                 delete body.plugins;
+                debugLog(`[Tool ${tool.id}] Plugins data:`, pluginsData);
+                debugLog(`[Tool ${tool.id}] Executing tool handler...`);
                 return executeToolWithStreaming(c, tool, body, agentInfo, pluginsData, false);
             }
             catch (error) {
-                console.error(`[Tool ${tool.id}] Error:`, error.message);
+                console.error(`[Tool ${tool.id}] ========== ERROR ==========`);
+                console.error(`[Tool ${tool.id}] Error:`, error);
+                console.error(`[Tool ${tool.id}] Stack:`, error.stack);
                 throw new http_exception_1.HTTPException(500, { message: "Internal server error" });
             }
         });
         // Tool execution with context endpoint
         app.post(`/tools/${tool.id}/executeAndGetNewContext`, async (c) => {
+            debugLog(`[Tool ${tool.id} +Context] ========== TOOL EXECUTION START (WITH CONTEXT) ==========`);
+            debugLog(`[Tool ${tool.id} +Context] Path: ${c.req.path}`);
+            debugLog(`[Tool ${tool.id} +Context] Method: ${c.req.method}`);
+            debugLog(`[Tool ${tool.id} +Context] Auth Method: ${c.get('authMethod')}`);
+            debugLog(`[Tool ${tool.id} +Context] Headers:`, {
+                authorization: c.req.header("Authorization") ? "Bearer ***" : undefined,
+                apiKey: c.req.header("X-DAIN-API-KEY") ? "***" : undefined,
+                smartAccountPDA: c.req.header("X-DAIN-SMART-ACCOUNT-PDA"),
+                webhookUrl: c.req.header("X-DAIN-WEBHOOK-URL"),
+            });
             try {
+                debugLog(`[Tool ${tool.id} +Context] Getting agent info...`);
                 const agentInfo = await getAgentInfo(c);
+                debugLog(`[Tool ${tool.id} +Context] Agent info:`, agentInfo);
+                debugLog(`[Tool ${tool.id} +Context] Parsing request body...`);
                 let body = await c.req.json();
+                debugLog(`[Tool ${tool.id} +Context] Request body keys:`, Object.keys(body));
+                debugLog(`[Tool ${tool.id} +Context] Request body:`, JSON.stringify(body, null, 2));
                 // Process plugins for the request
+                debugLog(`[Tool ${tool.id} +Context] Processing plugins...`);
                 body = await processPluginsForRequest(body, agentInfo);
                 // Extract plugins data for the tool context
                 const pluginsData = body.plugins || {};
                 delete body.plugins;
+                debugLog(`[Tool ${tool.id} +Context] Plugins data:`, pluginsData);
+                debugLog(`[Tool ${tool.id} +Context] Executing tool handler with context...`);
                 return executeToolWithStreaming(c, tool, body, agentInfo, pluginsData, true);
             }
             catch (error) {
-                console.error(`[Tool ${tool.id} +Context] Error:`, error.message);
+                console.error(`[Tool ${tool.id} +Context] ========== ERROR ==========`);
+                console.error(`[Tool ${tool.id} +Context] Error:`, error);
+                console.error(`[Tool ${tool.id} +Context] Stack:`, error.stack);
                 throw new http_exception_1.HTTPException(500, { message: "Internal server error" });
             }
         });