snow-flow 3.4.32 → 3.4.34

package/dist/mcp/base-mcp-server.d.ts

@@ -67,11 +67,6 @@ export declare abstract class BaseMCPServer {
      * Validate authentication with smart caching
      */
     protected validateAuth(): Promise<AuthResult>;
-    /**
-     * 🔴 SNOW-003 FIX: Enhanced retry logic with intelligent backoff and circuit breaker
-     * Addresses the 19% failure rate with better retry strategies and failure prevention
-     */
-    private executeWithRetry;
     /**
      * 🔴 SNOW-003 FIX: Calculate intelligent backoff based on error type and attempt
      */

package/dist/mcp/base-mcp-server.js

@@ -17,6 +17,7 @@ const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const servicenow_client_js_1 = require("../utils/servicenow-client.js");
 const snow_oauth_js_1 = require("../utils/snow-oauth.js");
 const logger_js_1 = require("../utils/logger.js");
+const response_limiter_js_1 = require("./shared/response-limiter.js");
 /**
  * Base class for all ServiceNow MCP servers
  * Provides common functionality to eliminate code duplication
@@ -78,7 +79,31 @@ class BaseMCPServer {
                     }
                 }
                 // Execute tool with retry logic
-                const result = await this.executeWithRetry(name, args);
+                let result = await this.executeWithRetry(name, args);
+                // Limit response size to prevent timeouts
+                const { limited, wasLimited, originalSize } = response_limiter_js_1.ResponseLimiter.limitResponse(result);
+                if (wasLimited) {
+                    this.logger.warn(`Response limited for ${name}: ${originalSize} bytes -> ${JSON.stringify(limited).length} bytes`);
+                    // Only create summary for EXTREMELY large responses (>2MB)
+                    // Normal widgets/flows should pass through fine with 500KB limit
+                    if (originalSize > 2000000) { // > 2MB - truly excessive
+                        result = response_limiter_js_1.ResponseLimiter.createSummaryResponse(result, name);
+                    }
+                    else {
+                        result = limited;
+                    }
+                }
+                // Add token tracking metadata
+                const responseSize = JSON.stringify(result).length;
+                const estimatedTokens = Math.ceil(responseSize / 4);
+                if (result && typeof result === 'object') {
+                    result._meta = {
+                        ...result._meta,
+                        tokenCount: estimatedTokens,
+                        responseSize,
+                        wasLimited
+                    };
+                }
                 // Update metrics
                 metrics.totalTime += Date.now() - startTime;
                 this.toolMetrics.set(name, metrics);
@@ -457,6 +482,38 @@ class BaseMCPServer {
     getToolHandler(name) {
         return this.toolHandlers.get(name);
     }
+    /**
+     * Execute tool with retry logic
+     */
+    async executeWithRetry(name, args, maxRetries = 3) {
+        const handler = this.getToolHandler(name);
+        if (!handler) {
+            throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Tool '${name}' not found`);
+        }
+        let lastError;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                // Execute the tool handler
+                const result = await handler(args);
+                return result;
+            }
+            catch (error) {
+                lastError = error;
+                // Don't retry on non-retryable errors
+                if (error.code === types_js_1.ErrorCode.InvalidRequest ||
+                    error.code === types_js_1.ErrorCode.MethodNotFound) {
+                    throw error;
+                }
+                // Log retry attempt
+                if (attempt < maxRetries) {
+                    this.logger.warn(`Tool ${name} failed (attempt ${attempt}/${maxRetries}), retrying...`, error.message);
+                    await new Promise(resolve => setTimeout(resolve, Math.min(1000 * attempt, 5000)));
+                }
+            }
+        }
+        // All retries failed
+        throw lastError;
+    }
     /**
      * Graceful shutdown
      */

package/dist/mcp/shared/response-limiter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * MCP Response Limiter
+ * Prevents oversized responses that cause timeouts in Claude Code
+ */
+export declare class ResponseLimiter {
+    private static readonly MAX_RESPONSE_SIZE;
+    private static readonly MAX_ARRAY_ITEMS;
+    private static readonly MAX_TOKEN_ESTIMATE;
+    /**
+     * Limit response size to prevent timeouts
+     */
+    static limitResponse(data: any): {
+        limited: any;
+        wasLimited: boolean;
+        originalSize?: number;
+    };
+    /**
+     * Recursively limit object size
+     */
+    private static limitObject;
+    /**
+     * Create a summary response when data is too large
+     */
+    static createSummaryResponse(data: any, operation: string): any;
+}
+//# sourceMappingURL=response-limiter.d.ts.map

package/dist/mcp/shared/response-limiter.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * MCP Response Limiter
+ * Prevents oversized responses that cause timeouts in Claude Code
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseLimiter = void 0;
+class ResponseLimiter {
+    /**
+     * Limit response size to prevent timeouts
+     */
+    static limitResponse(data) {
+        const originalString = JSON.stringify(data);
+        const originalSize = originalString.length;
+        // If response is small enough, return as-is
+        if (originalSize <= this.MAX_RESPONSE_SIZE) {
+            return { limited: data, wasLimited: false };
+        }
+        // Response too large - need to limit it
+        const limited = this.limitObject(data);
+        return {
+            limited,
+            wasLimited: true,
+            originalSize
+        };
+    }
+    /**
+     * Recursively limit object size
+     */
+    static limitObject(obj, depth = 0) {
+        // Don't go too deep
+        if (depth > 5) {
+            return '[DEPTH_LIMITED]';
+        }
+        // Handle null/undefined
+        if (obj === null || obj === undefined) {
+            return obj;
+        }
+        // Handle primitives
+        if (typeof obj !== 'object') {
+            // Limit string length - 10KB per string field is reasonable
+            if (typeof obj === 'string' && obj.length > 10000) {
+                return obj.substring(0, 10000) + '... [TRUNCATED]';
+            }
+            return obj;
+        }
+        // Handle arrays
+        if (Array.isArray(obj)) {
+            if (obj.length > this.MAX_ARRAY_ITEMS) {
+                return [
+                    ...obj.slice(0, this.MAX_ARRAY_ITEMS).map(item => this.limitObject(item, depth + 1)),
+                    `[... ${obj.length - this.MAX_ARRAY_ITEMS} more items]`
+                ];
+            }
+            return obj.map(item => this.limitObject(item, depth + 1));
+        }
+        // Handle objects
+        const limited = {};
+        const keys = Object.keys(obj);
+        // Limit number of keys
+        const maxKeys = 50;
+        const keysToProcess = keys.slice(0, maxKeys);
+        for (const key of keysToProcess) {
+            limited[key] = this.limitObject(obj[key], depth + 1);
+        }
+        if (keys.length > maxKeys) {
+            limited._truncated = `${keys.length - maxKeys} more properties omitted`;
+        }
+        return limited;
+    }
+    /**
+     * Create a summary response when data is too large
+     */
+    static createSummaryResponse(data, operation) {
+        const originalSize = JSON.stringify(data).length;
+        const estimatedTokens = Math.ceil(originalSize / 4);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `⚠️ Response too large (${estimatedTokens} tokens, ${originalSize} bytes)
+
+Operation: ${operation}
+Status: Success (data limited to prevent timeout)
+
+Summary:
+- Original size: ${(originalSize / 1024 / 1024).toFixed(2)}MB
+- Token estimate: ${estimatedTokens}
+- Response limit: ${(this.MAX_RESPONSE_SIZE / 1024).toFixed(0)}KB
+
+💡 Tips to reduce response size:
+1. Use specific field queries instead of '*'
+2. Add pagination with smaller limits
+3. Filter results more specifically
+4. Use count operations instead of full data retrieval
+
+Note: You can increase limits via environment variables:
+- MCP_MAX_RESPONSE_SIZE (default: 500000 bytes)
+- MCP_MAX_ARRAY_ITEMS (default: 500 items)`
+                }],
+            _meta: {
+                limited: true,
+                originalSize,
+                tokenEstimate: estimatedTokens
+            }
+        };
+    }
+}
+exports.ResponseLimiter = ResponseLimiter;
+// Configurable via environment variable, default to 500KB (reasonable for widgets/flows)
+ResponseLimiter.MAX_RESPONSE_SIZE = parseInt(process.env.MCP_MAX_RESPONSE_SIZE || '500000'); // 500KB default
+ResponseLimiter.MAX_ARRAY_ITEMS = parseInt(process.env.MCP_MAX_ARRAY_ITEMS || '500'); // 500 items default
+ResponseLimiter.MAX_TOKEN_ESTIMATE = 125000; // ~500KB / 4 chars per token
+//# sourceMappingURL=response-limiter.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "3.4.32",
+  "version": "3.4.34",
   "description": "ServiceNow development framework with MCP server integration. Executes background scripts using ES5 JavaScript only (ServiceNow Rhino engine requirement). Provides 17 MCP servers for complete ServiceNow operations including widget deployment with coherence validation, table operations, script execution, machine learning, advanced features, and comprehensive platform management.",
   "main": "dist/index.js",
   "type": "commonjs",