@dainprotocol/service-sdk 2.0.78 → 2.0.79

package/dist/service/server.js

@@ -22,33 +22,35 @@ const auth_2 = require("./auth");
 const core_1 = require("./core");
 const hitl_1 = require("./hitl");
 const VERBOSE_SERVICE_LOGS = process.env.DAIN_VERBOSE_SERVICE_LOGS === "true";
-const debugLog = (...args) => {
+function debugLog(...args) {
     if (VERBOSE_SERVICE_LOGS) {
         console.log(...args);
     }
-};
-const debugWarn = (...args) => {
+}
+function debugWarn(...args) {
     if (VERBOSE_SERVICE_LOGS) {
         console.warn(...args);
     }
-};
-debugLog("OAuth2 package version:", package_json_1.default.dependencies["@dainprotocol/oauth2-token-manager"]);
+}
+/**
+ * Safely parse JSON body from request, returning empty object on failure.
+ */
+async function safeParseBody(c) {
+    try {
+        return await c.req.json();
+    }
+    catch {
+        return {};
+    }
+}
 /**
- * Middleware factory to require specific OAuth scopes
- * Defense-in-depth: Validates scopes even though JWT middleware already checked them
- *
- * @param requiredScope Single scope or array of scopes (ANY match required)
- * @returns Hono middleware
- *
- * @example
- * app.get("/widgets", requireScope("widgets.read"), async (c) => { ... })
- * app.post("/admin", requireScope(["admin.*", "super.admin"]), async (c) => { ... })
+ * Middleware factory to require specific OAuth scopes.
+ * Defense-in-depth: Validates scopes even though JWT middleware already checked them.
  */
 function requireScope(requiredScope) {
     return async (c, next) => {
         const scopes = c.get('scope') || [];
         const requiredScopes = Array.isArray(requiredScope) ? requiredScope : [requiredScope];
-        // Check if user has at least one of the required scopes
         const hasRequiredScope = requiredScopes.some(scope => (0, auth_2.hasScope)(scopes, scope));
         if (!hasRequiredScope) {
             throw new http_exception_1.HTTPException(403, {
@@ -304,18 +306,9 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
         console.log(`[Service SDK Server] Returning ${toolInfo.length} tools`);
         return c.json(toolInfo);
     });
-    // POST version of the basic contexts listing
     app.post("/contexts/list", async (c) => {
         const agentInfo = await getAgentInfo(c);
-        // Get plugin data from request body
-        let body = {};
-        try {
-            body = await c.req.json();
-        }
-        catch (error) {
-            body = {}; // Default to empty body if parsing fails
-        }
-        // Process plugins for the request
+        const body = await safeParseBody(c);
         const processedPluginData = await processPluginsForRequest(body, agentInfo);
         // Merge manual contexts with auto-generated contexts (direct provider + skills)
         const autoContexts = app.oauth2?.getDirectProviderContexts?.() || [];
@@ -331,41 +324,27 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
         const processedResponse = await processPluginsForResponse(contextInfo, body, { extraData: { plugins: processedPluginData.plugins } });
         return c.json(processedResponse);
     });
-    // Primary endpoint for getting a context's data with plugin support
     app.post("/contexts/:contextId", async (c) => {
-        // Merge manual contexts with auto-generated contexts (direct provider + skills)
         const autoContexts = app.oauth2?.getDirectProviderContexts?.() || [];
         const serviceSlug = (0, core_1.toSlug)(metadata.title);
         const skillsContext = config.skills?.getSkillsContext?.(serviceSlug);
         const allContexts = [...contexts, ...autoContexts, ...(skillsContext ? [skillsContext] : [])];
-        const context = allContexts.find((context) => context.id === c.req.param("contextId"));
+        const context = allContexts.find((ctx) => ctx.id === c.req.param("contextId"));
         if (context) {
             const agentInfo = await getAgentInfo(c);
-            // Get plugin data from request body
-            let body = {};
-            try {
-                body = await c.req.json();
-            }
-            catch (error) {
-                body = {}; // Default to empty body if parsing fails
-            }
-            // Process plugins for the request
+            const body = await safeParseBody(c);
             const processedPluginData = await processPluginsForRequest(body, agentInfo);
-            // Get oauth2 client if available
-            const oauth2Client = app.oauth2 ? app.oauth2.getClient() : undefined;
-            // Get context data with plugins and oauth2Client
+            const oauth2Client = app.oauth2?.getClient();
             const contextData = await context.getContextData(agentInfo, {
                 plugins: processedPluginData.plugins,
-                oauth2Client: oauth2Client
+                oauth2Client
             });
-            // Create the response
             const response = {
                 id: context.id,
                 name: context.name,
                 description: context.description,
                 data: contextData
             };
-            // Process plugins for the response
             const processedResponse = await processPluginsForResponse(response, body, { extraData: { plugins: processedPluginData.plugins } });
             return c.json(processedResponse);
         }
@@ -373,121 +352,67 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
             throw new http_exception_1.HTTPException(404, { message: "Context not found" });
         }
     });
-    // Primary endpoint for getting all contexts with plugin support
     app.post("/contexts", async (c) => {
         const agentInfo = await getAgentInfo(c);
-        // Get plugin data from request body
-        let body = {};
-        try {
-            body = await c.req.json();
-        }
-        catch (error) {
-            body = {}; // Default to empty body if parsing fails
-        }
-        // Process plugins for the request
+        const body = await safeParseBody(c);
         const processedPluginData = await processPluginsForRequest(body, agentInfo);
-        // Get oauth2 client if available
-        const oauth2Client = app.oauth2 ? app.oauth2.getClient() : undefined;
-        // Merge manual contexts with auto-generated contexts (direct provider + skills)
+        const oauth2Client = app.oauth2?.getClient();
         const autoContexts = app.oauth2?.getDirectProviderContexts?.() || [];
         const serviceSlug = (0, core_1.toSlug)(metadata.title);
         const skillsContext = config.skills?.getSkillsContext?.(serviceSlug);
         const allContexts = [...contexts, ...autoContexts, ...(skillsContext ? [skillsContext] : [])];
-        // Get all contexts with plugins and oauth2Client
-        const contextsFull = await Promise.all(allContexts.map(async (context) => ({
-            id: context.id,
-            name: context.name,
-            description: context.description,
-            data: await context.getContextData(agentInfo, {
+        const contextsFull = await Promise.all(allContexts.map(async (ctx) => ({
+            id: ctx.id,
+            name: ctx.name,
+            description: ctx.description,
+            data: await ctx.getContextData(agentInfo, {
                 plugins: processedPluginData.plugins,
-                oauth2Client: oauth2Client
+                oauth2Client
             }),
         })));
-        // Create the response
-        const response = contextsFull;
-        // Process plugins for the response
-        const processedResponse = await processPluginsForResponse(response, body, { extraData: { plugins: processedPluginData.plugins } });
+        const processedResponse = await processPluginsForResponse(contextsFull, body, { extraData: { plugins: processedPluginData.plugins } });
         return c.json(processedResponse);
     });
-    // Get widget IDs for current user
     app.post("/widgets", async (c) => {
         const agentInfo = await getAgentInfo(c);
-        // Get plugin data from request body
-        let body = {};
-        try {
-            body = await c.req.json();
-        }
-        catch (error) {
-            body = {}; // Default to empty body if parsing fails
-        }
-        // Process plugins for the request
+        const body = await safeParseBody(c);
         const processedPluginData = await processPluginsForRequest(body, agentInfo);
-        // Get user-specific widget IDs
-        let widgetIds;
-        if (config.getUserWidgets) {
-            widgetIds = await config.getUserWidgets(agentInfo, {
-                plugins: processedPluginData.plugins
-            });
-        }
-        else {
-            // Default: return all widget IDs
-            widgetIds = widgets.map(widget => widget.id);
-        }
-        // Process plugins for the response
+        const widgetIds = config.getUserWidgets
+            ? await config.getUserWidgets(agentInfo, { plugins: processedPluginData.plugins })
+            : widgets.map(widget => widget.id);
         const processedResponse = await processPluginsForResponse(widgetIds, body, { extraData: { plugins: processedPluginData.plugins } });
         return c.json(processedResponse);
     });
-    // Get all widgets with their data
     app.post("/widgets/all", async (c) => {
         const agentInfo = await getAgentInfo(c);
-        // Get plugin data from request body
-        let body = {};
-        try {
-            body = await c.req.json();
-        }
-        catch (error) {
-            body = {}; // Default to empty body if parsing fails
-        }
-        // Process plugins for the request
+        const body = await safeParseBody(c);
         const processedPluginData = await processPluginsForRequest(body, agentInfo);
-        // Get user-specific widget IDs
-        let widgetIds;
-        if (config.getUserWidgets) {
-            widgetIds = await config.getUserWidgets(agentInfo, {
-                plugins: processedPluginData.plugins
-            });
-        }
-        else {
-            // Default: return all widget IDs
-            widgetIds = widgets.map(widget => widget.id);
-        }
-        // Get widgets with their data
-        const oauth2Client = app.oauth2 ? app.oauth2.getClient() : undefined;
+        const widgetIds = config.getUserWidgets
+            ? await config.getUserWidgets(agentInfo, { plugins: processedPluginData.plugins })
+            : widgets.map(widget => widget.id);
+        const oauth2Client = app.oauth2?.getClient();
         const widgetsFull = await Promise.all(widgetIds.map(async (widgetId) => {
             const widget = widgets.find(w => w.id === widgetId);
             if (!widget)
                 return null;
             const widgetData = await widget.getWidget(agentInfo, {
                 plugins: processedPluginData.plugins,
-                oauth2Client: oauth2Client,
-                app: app // Pass app for access to setupManager via app.oauth2.getSetupManager()
+                oauth2Client,
+                app
             });
             return {
                 id: widget.id,
                 name: widget.name,
                 description: widget.description,
                 icon: widget.icon,
-                size: widget.size || "sm", // Include size with default
+                size: widget.size || "sm",
                 ...widgetData
             };
         }));
-        // Filter out null widgets (not found)
         const validWidgets = widgetsFull.filter(w => w !== null);
-        // Process plugins for the response
         const processedResponse = await processPluginsForResponse(validWidgets, body, { extraData: { plugins: processedPluginData.plugins } });
         return c.json(processedResponse);
     });
-    // Get specific widget with data
     app.post("/widgets/:widgetId", async (c) => {
         const widgetId = c.req.param("widgetId");
         const widget = widgets.find(w => w.id === widgetId);
@@ -495,86 +420,49 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
             throw new http_exception_1.HTTPException(404, { message: "Widget not found" });
         }
         const agentInfo = await getAgentInfo(c);
-        // Get plugin data from request body
-        let body = {};
-        try {
-            body = await c.req.json();
-        }
-        catch (error) {
-            body = {}; // Default to empty body if parsing fails
-        }
-        // Process plugins for the request
+        const body = await safeParseBody(c);
         const processedPluginData = await processPluginsForRequest(body, agentInfo);
-        // Check if user has access to this widget
         if (config.getUserWidgets) {
             const userWidgetIds = await config.getUserWidgets(agentInfo, {
                 plugins: processedPluginData.plugins
             });
-            // Get the home UI widget ID for this user (if configured)
             let homeUIWidgetId = null;
             if (config.homeUI) {
-                if (typeof config.homeUI === 'string') {
-                    homeUIWidgetId = config.homeUI;
-                }
-                else {
-                    homeUIWidgetId = await config.homeUI(agentInfo, {
-                        plugins: processedPluginData.plugins
-                    });
-                }
+                homeUIWidgetId = typeof config.homeUI === 'string'
+                    ? config.homeUI
+                    : await config.homeUI(agentInfo, { plugins: processedPluginData.plugins });
             }
-            // Allow access if widget is in getUserWidgets OR if it's the homeUI widget
             if (!userWidgetIds.includes(widgetId) && widgetId !== homeUIWidgetId) {
                 throw new http_exception_1.HTTPException(403, { message: "Access denied to this widget" });
             }
         }
-        // Get widget data with plugins and oauth2Client
-        const oauth2Client = app.oauth2 ? app.oauth2.getClient() : undefined;
+        const oauth2Client = app.oauth2?.getClient();
         const widgetData = await widget.getWidget(agentInfo, {
             plugins: processedPluginData.plugins,
-            oauth2Client: oauth2Client,
-            app: app // Pass app for access to setupManager via app.oauth2.getSetupManager()
+            oauth2Client,
+            app
         });
-        // Create the response
         const response = {
             id: widget.id,
             name: widget.name,
             description: widget.description,
             icon: widget.icon,
-            size: widget.size || "sm", // Include size with default
+            size: widget.size || "sm",
             ...widgetData
         };
-        // Process plugins for the response
         const processedResponse = await processPluginsForResponse(response, body, { extraData: { plugins: processedPluginData.plugins } });
         return c.json(processedResponse);
     });
-    // Get home UI widget ID for current user
     app.post("/homeUI", async (c) => {
-        // Return null widgetId if homeUI is not configured (instead of 404)
         if (!config.homeUI) {
             return c.json({ widgetId: null });
         }
         const agentInfo = await getAgentInfo(c);
-        // Get plugin data from request body
-        let body = {};
-        try {
-            body = await c.req.json();
-        }
-        catch (error) {
-            body = {}; // Default to empty body if parsing fails
-        }
-        // Process plugins for the request
+        const body = await safeParseBody(c);
         const processedPluginData = await processPluginsForRequest(body, agentInfo);
-        // Get home UI widget ID
-        let homeUIWidgetId;
-        if (typeof config.homeUI === 'string') {
-            homeUIWidgetId = config.homeUI;
-        }
-        else {
-            homeUIWidgetId = await config.homeUI(agentInfo, {
-                plugins: processedPluginData.plugins
-            });
-        }
-        // Return null if widget ID is empty or widget doesn't exist
+        const homeUIWidgetId = typeof config.homeUI === 'string'
+            ? config.homeUI
+            : await config.homeUI(agentInfo, { plugins: processedPluginData.plugins });
         if (!homeUIWidgetId) {
             return c.json({ widgetId: null });
         }
@@ -582,145 +470,77 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
         if (!widget) {
             return c.json({ widgetId: null });
         }
-        // Process plugins for the response
         const processedResponse = await processPluginsForResponse({ widgetId: homeUIWidgetId }, body, { extraData: { plugins: processedPluginData.plugins } });
         return c.json(processedResponse);
     });
-    app.get("/datasources", (c) => {
-        const datasourceInfo = datasources.map((datasource) => ({
+    function mapDatasourceInfo(datasource) {
+        return {
             id: datasource.id,
             name: datasource.name,
             description: datasource.description,
             type: datasource.type,
             inputSchema: (0, schemaStructure_1.getDetailedSchemaStructure)(datasource.input),
-        }));
-        return c.json(datasourceInfo);
+        };
+    }
+    app.get("/datasources", (c) => {
+        return c.json(datasources.map(mapDatasourceInfo));
     });
-    // POST version of the basic datasources listing
     app.post("/datasources/list", async (c) => {
         const agentInfo = await getAgentInfo(c);
-        // Get plugin data from request body
-        let body = {};
-        try {
-            body = await c.req.json();
-        }
-        catch (error) {
-            body = {}; // Default to empty body if parsing fails
-        }
-        // Process plugins for the request
+        const body = await safeParseBody(c);
         const processedPluginData = await processPluginsForRequest(body, agentInfo);
-        const datasourceInfo = datasources.map((datasource) => ({
-            id: datasource.id,
-            name: datasource.name,
-            description: datasource.description,
-            type: datasource.type,
-            inputSchema: (0, schemaStructure_1.getDetailedSchemaStructure)(datasource.input),
-        }));
-        // Process plugins for the response
-        const processedResponse = await processPluginsForResponse(datasourceInfo, body, { extraData: { plugins: processedPluginData.plugins } });
+        const processedResponse = await processPluginsForResponse(datasources.map(mapDatasourceInfo), body, { extraData: { plugins: processedPluginData.plugins } });
         return c.json(processedResponse);
     });
-    // Primary endpoint for getting all datasources with plugin support
     app.post("/datasources/all", async (c) => {
         const agentInfo = await getAgentInfo(c);
-        // Get plugin data from request body
-        let body = {};
-        try {
-            body = await c.req.json();
-        }
-        catch (error) {
-            body = {}; // Default to empty body if parsing fails
-        }
-        // Process plugins for the request
+        const body = await safeParseBody(c);
         const processedPluginData = await processPluginsForRequest(body, agentInfo);
-        // Get all datasources
-        const datasourcesFull = datasources.map((datasource) => ({
-            id: datasource.id,
-            name: datasource.name,
-            description: datasource.description,
-            type: datasource.type,
-            inputSchema: (0, schemaStructure_1.getDetailedSchemaStructure)(datasource.input),
-        }));
-        // Process plugins for the response
-        const processedResponse = await processPluginsForResponse(datasourcesFull, body, { extraData: { plugins: processedPluginData.plugins } });
+        const processedResponse = await processPluginsForResponse(datasources.map(mapDatasourceInfo), body, { extraData: { plugins: processedPluginData.plugins } });
         return c.json(processedResponse);
     });
     app.post("/datasources/:datasourceId", async (c) => {
-        const datasource = datasources.find((datasource) => datasource.id === c.req.param("datasourceId"));
-        if (datasource) {
-            const agentInfo = await getAgentInfo(c);
-            let params = await c.req.json();
-            // Process plugins for the request
-            params = await processPluginsForRequest(params, agentInfo);
-            // Extract plugins data for the datasource
-            const pluginsData = params.plugins || {};
-            delete params.plugins;
-            try {
-                const parsedParams = datasource.input.parse(params);
-                // Get oauth2 client if available
-                const oauth2Client = app.oauth2 ? app.oauth2.getClient() : undefined;
-                // Get datasource with plugins and oauth2Client
-                const data = await datasource.getDatasource(agentInfo, parsedParams, {
-                    plugins: pluginsData,
-                    oauth2Client: oauth2Client
-                });
-                // Create the response
-                const response = {
-                    id: datasource.id,
-                    name: datasource.name,
-                    description: datasource.description,
-                    type: datasource.type,
-                    data: data,
-                };
-                // Process plugins for the response
-                const processedResponse = await processPluginsForResponse(response, { plugins: pluginsData }, { extraData: { plugins: pluginsData } });
-                return c.json(processedResponse);
-            }
-            catch (error) {
-                if (error instanceof zod_1.z.ZodError) {
-                    const missingParams = error.issues
-                        .map((issue) => issue.path.join("."))
-                        .join(", ");
-                    return c.json({
-                        error: `Missing or invalid parameters: ${missingParams}`,
-                        code: "INVALID_PARAMS"
-                    }, 400);
-                }
-                throw error;
-            }
-        }
-        else {
+        const datasource = datasources.find((ds) => ds.id === c.req.param("datasourceId"));
+        if (!datasource) {
             throw new http_exception_1.HTTPException(404, { message: "Datasource not found" });
         }
-    });
-    // Agents list endpoint
-    app.get("/agents", (c) => {
-        const agentInfo = agents.map((agent) => ({
-            id: agent.id,
-            name: agent.name,
-            context: agent.context,
-            prompt: agent.prompt,
-            resolveCondition: agent.resolveCondition,
-            serviceConnections: agent.serviceConnections || [process.env.BASE_URL || 'http://localhost:3000'],
-            inputSchema: (0, schemaStructure_1.zodToJsonSchema)(agent.input),
-            outputSchema: (0, schemaStructure_1.zodToJsonSchema)(agent.output),
-        }));
-        return c.json(agentInfo);
-    });
-    // POST version of the basic agents listing
-    app.post("/agents/list", async (c) => {
         const agentInfo = await getAgentInfo(c);
-        // Get plugin data from request body
-        let body = {};
+        let params = await c.req.json();
+        params = await processPluginsForRequest(params, agentInfo);
+        const pluginsData = params.plugins || {};
+        delete params.plugins;
         try {
-            body = await c.req.json();
+            const parsedParams = datasource.input.parse(params);
+            const oauth2Client = app.oauth2?.getClient();
+            const data = await datasource.getDatasource(agentInfo, parsedParams, {
+                plugins: pluginsData,
+                oauth2Client
+            });
+            const response = {
+                id: datasource.id,
+                name: datasource.name,
+                description: datasource.description,
+                type: datasource.type,
+                data,
+            };
+            const processedResponse = await processPluginsForResponse(response, { plugins: pluginsData }, { extraData: { plugins: pluginsData } });
+            return c.json(processedResponse);
         }
         catch (error) {
-            body = {}; // Default to empty body if parsing fails
+            if (error instanceof zod_1.z.ZodError) {
+                const missingParams = error.issues
+                    .map((issue) => issue.path.join("."))
+                    .join(", ");
+                return c.json({
+                    error: `Missing or invalid parameters: ${missingParams}`,
+                    code: "INVALID_PARAMS"
+                }, 400);
+            }
+            throw error;
         }
-        // Process plugins for the request
-        const processedPluginData = await processPluginsForRequest(body, agentInfo);
-        const agentsInfo = agents.map((agent) => ({
+    });
+    function mapAgentInfo(agent) {
+        return {
             id: agent.id,
             name: agent.name,
             context: agent.context,
@@ -729,145 +549,91 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
             serviceConnections: agent.serviceConnections || [process.env.BASE_URL || 'http://localhost:3000'],
             inputSchema: (0, schemaStructure_1.zodToJsonSchema)(agent.input),
             outputSchema: (0, schemaStructure_1.zodToJsonSchema)(agent.output),
-        }));
-        // Process plugins for the response
-        const processedResponse = await processPluginsForResponse(agentsInfo, body, { extraData: { plugins: processedPluginData.plugins } });
+        };
+    }
+    app.get("/agents", (c) => {
+        return c.json(agents.map(mapAgentInfo));
+    });
+    app.post("/agents/list", async (c) => {
+        const agentInfo = await getAgentInfo(c);
+        const body = await safeParseBody(c);
+        const processedPluginData = await processPluginsForRequest(body, agentInfo);
+        const processedResponse = await processPluginsForResponse(agents.map(mapAgentInfo), body, { extraData: { plugins: processedPluginData.plugins } });
         return c.json(processedResponse);
     });
-    // Get specific agent
     app.get("/agents/:agentId", (c) => {
         const agent = agents.find((a) => a.id === c.req.param("agentId"));
-        if (agent) {
-            const agentDetails = {
-                id: agent.id,
-                name: agent.name,
-                context: agent.context,
-                prompt: agent.prompt,
-                resolveCondition: agent.resolveCondition,
-                serviceConnections: agent.serviceConnections || [process.env.BASE_URL || 'http://localhost:3000'],
-                inputSchema: (0, schemaStructure_1.zodToJsonSchema)(agent.input),
-                outputSchema: (0, schemaStructure_1.zodToJsonSchema)(agent.output),
-            };
-            return c.json(agentDetails);
-        }
-        else {
+        if (!agent) {
             throw new http_exception_1.HTTPException(404, { message: "Agent not found" });
         }
+        return c.json(mapAgentInfo(agent));
     });
-    // POST version for getting specific agent with plugin support
     app.post("/agents/:agentId", async (c) => {
         const agent = agents.find((a) => a.id === c.req.param("agentId"));
-        if (agent) {
-            const agentInfo = await getAgentInfo(c);
-            // Get plugin data from request body
-            let body = {};
-            try {
-                body = await c.req.json();
-            }
-            catch (error) {
-                body = {}; // Default to empty body if parsing fails
-            }
-            // Process plugins for the request
-            const processedPluginData = await processPluginsForRequest(body, agentInfo);
-            const agentDetails = {
-                id: agent.id,
-                name: agent.name,
-                context: agent.context,
-                prompt: agent.prompt,
-                resolveCondition: agent.resolveCondition,
-                serviceConnections: agent.serviceConnections || [process.env.BASE_URL || 'http://localhost:3000'],
-                inputSchema: (0, schemaStructure_1.zodToJsonSchema)(agent.input),
-                outputSchema: (0, schemaStructure_1.zodToJsonSchema)(agent.output),
-            };
-            // Process plugins for the response
-            const processedResponse = await processPluginsForResponse(agentDetails, body, { extraData: { plugins: processedPluginData.plugins } });
-            return c.json(processedResponse);
-        }
-        else {
+        if (!agent) {
             throw new http_exception_1.HTTPException(404, { message: "Agent not found" });
         }
+        const agentInfo = await getAgentInfo(c);
+        const body = await safeParseBody(c);
+        const processedPluginData = await processPluginsForRequest(body, agentInfo);
+        const processedResponse = await processPluginsForResponse(mapAgentInfo(agent), body, { extraData: { plugins: processedPluginData.plugins } });
+        return c.json(processedResponse);
     });
+    function fixEmptySchemas(schema) {
+        if (!schema || typeof schema !== 'object')
+            return;
+        if (schema.properties && typeof schema.properties === 'object') {
+            const props = schema.properties;
+            for (const key of Object.keys(props)) {
+                const prop = props[key];
+                if (prop && typeof prop === 'object' && Object.keys(prop).length === 0) {
+                    props[key] = { type: 'object' };
+                }
+                fixEmptySchemas(prop);
+            }
+        }
+        if (schema.items) {
+            fixEmptySchemas(schema.items);
+        }
+    }
+    function mapToolToJsonSchema(tool) {
+        let inputSchema = (0, schemaStructure_1.zodToJsonSchema)(tool.input);
+        let outputSchema = (0, schemaStructure_1.zodToJsonSchema)(tool.output);
+        if (!inputSchema.type) {
+            inputSchema = { ...inputSchema, type: 'object' };
+        }
+        if (!outputSchema.type) {
+            outputSchema = { ...outputSchema, type: 'object' };
+        }
+        fixEmptySchemas(inputSchema);
+        fixEmptySchemas(outputSchema);
+        return {
+            id: tool.id,
+            name: tool.name,
+            description: tool.description,
+            inputSchema,
+            outputSchema,
+            interface: tool.interface,
+            suggestConfirmation: tool.suggestConfirmation,
+            supportsUserActions: tool.supportsUserActions,
+        };
+    }
     app.get("/getAllToolsAsJsonSchema", (c) => {
-        const toolInfo = tools.map((tool) => {
-            const inputSchema = (0, schemaStructure_1.zodToJsonSchema)(tool.input);
-            const outputSchema = (0, schemaStructure_1.zodToJsonSchema)(tool.output);
-            return {
-                id: tool.id,
-                name: tool.name,
-                description: tool.description,
-                inputSchema,
-                outputSchema,
-                interface: tool.interface,
-                suggestConfirmation: tool.suggestConfirmation,
-                supportsUserActions: tool.supportsUserActions,
-            };
-        });
         return c.json({
-            tools: toolInfo,
+            tools: tools.map(mapToolToJsonSchema),
             reccomendedPrompts: toolboxes.map((toolbox) => toolbox.recommendedPrompt),
         });
     });
-    // POST version of getAllToolsAsJsonSchema
     app.post("/getAllToolsAsJsonSchema", async (c) => {
         const agentInfo = await getAgentInfo(c);
-        // Get plugin data from request body
-        let body = {};
-        try {
-            body = await c.req.json();
-        }
-        catch (error) {
-            body = {}; // Default to empty body if parsing fails
-        }
-        // Process plugins for the request
+        const body = await safeParseBody(c);
         const processedPluginData = await processPluginsForRequest(body, agentInfo);
-        const toolInfo = tools.map((tool) => {
-            let inputSchema = (0, schemaStructure_1.zodToJsonSchema)(tool.input);
-            let outputSchema = (0, schemaStructure_1.zodToJsonSchema)(tool.output);
-            // Ensure inputSchema has type: 'object' at root level (butterfly-web compatibility)
-            if (!inputSchema.type) {
-                inputSchema = { ...inputSchema, type: 'object' };
-            }
-            if (!outputSchema.type) {
-                outputSchema = { ...outputSchema, type: 'object' };
-            }
-            // Fix empty object schemas (from z.any()) to have type
-            const fixEmptySchemas = (schema) => {
-                if (schema && typeof schema === 'object') {
-                    if (schema.properties) {
-                        Object.keys(schema.properties).forEach(key => {
-                            const prop = schema.properties[key];
-                            if (prop && typeof prop === 'object' && Object.keys(prop).length === 0) {
-                                schema.properties[key] = { type: 'object' };
-                            }
-                            fixEmptySchemas(prop);
-                        });
-                    }
-                    if (schema.items) {
-                        fixEmptySchemas(schema.items);
-                    }
-                }
-            };
-            fixEmptySchemas(inputSchema);
-            fixEmptySchemas(outputSchema);
-            console.log(`[getAllToolsAsJsonSchema POST] Tool: ${tool.id}`);
-            console.log(`[getAllToolsAsJsonSchema POST] Input Schema:`, JSON.stringify(inputSchema, null, 2));
-            return {
-                id: tool.id,
-                name: tool.name,
-                description: tool.description,
-                inputSchema,
-                outputSchema,
-                interface: tool.interface,
-                suggestConfirmation: tool.suggestConfirmation,
-                supportsUserActions: tool.supportsUserActions,
-            };
-        });
+        const toolInfo = tools.map(mapToolToJsonSchema);
+        debugLog(`[getAllToolsAsJsonSchema POST] Returning ${toolInfo.length} tools`);
         const response = {
             tools: toolInfo,
             reccomendedPrompts: toolboxes.map((toolbox) => toolbox.recommendedPrompt),
         };
-        console.log(`[getAllToolsAsJsonSchema POST] Returning ${toolInfo.length} tools`);
-        // Process plugins for the response
         const processedResponse = await processPluginsForResponse(response, body, { extraData: { plugins: processedPluginData.plugins } });
         return c.json(processedResponse);
     });
@@ -1385,23 +1151,11 @@ function setupHttpServer(config, tools, services, toolboxes, metadata, privateKe
     app.get("/exampleQueries", (c) => {
         return c.json(config.exampleQueries || []);
     });
-    // POST version of exampleQueries with plugin support
     app.post("/exampleQueries", async (c) => {
         const agentInfo = await getAgentInfo(c);
-        // Get plugin data from request body
-        let body = {};
-        try {
-            body = await c.req.json();
-        }
-        catch (error) {
-            body = {}; // Default to empty body if parsing fails
-        }
-        // Process plugins for the request
+        const body = await safeParseBody(c);
         const processedPluginData = await processPluginsForRequest(body, agentInfo);
-        // Get example queries (or empty array if not configured)
-        const queries = config.exampleQueries || [];
-        // Process plugins for the response
-        const processedResponse = await processPluginsForResponse(queries, body, { extraData: { plugins: processedPluginData.plugins } });
+        const processedResponse = await processPluginsForResponse(config.exampleQueries || [], body, { extraData: { plugins: processedPluginData.plugins } });
         return c.json(processedResponse);
     });
     // Services list endpoint