@kya-os/mcp-i-core 1.2.2-canary.33 → 1.2.2-canary.35

package/src/services/access-control.service.ts

@@ -376,7 +376,7 @@ export class AccessControlApiService {
       });
 
       const responseText = await httpResponse.text();
-      
+
       // CRITICAL: Log raw response IMMEDIATELY before parsing/validation
       // This will help us debug validation failures
       console.error(`[AccessControl] 🔍 RAW API RESPONSE (before parsing):`, {
@@ -388,15 +388,17 @@ export class AccessControlApiService {
         responseTextPreview: responseText.substring(0, 500),
         fullResponseText: responseText, // Full response for debugging
       });
-      
+
       const responseData = this.parseResponseJSON(httpResponse, responseText);
-      
+
       // Log parsed response immediately after parsing
       console.error(`[AccessControl] 🔍 PARSED RESPONSE DATA:`, {
         correlationId,
         status: httpResponse.status,
         responseDataType: typeof responseData,
-        responseDataKeys: Object.keys((responseData as Record<string, unknown>) || {}),
+        responseDataKeys: Object.keys(
+          (responseData as Record<string, unknown>) || {}
+        ),
         responseData: JSON.stringify(responseData, null, 2),
       });
 
@@ -509,31 +511,131 @@ export class AccessControlApiService {
       if (wrappedResponse.success !== undefined && wrappedResponse.data) {
         // Response is wrapped in { success, data }
         // Extract data and add success field if missing (for schema validation)
-        const dataToValidate = wrappedResponse.data as Record<string, unknown>;
-        
+        // CRITICAL: Ensure data is actually an object, not a string or other type
+        let dataToValidate: Record<string, unknown>;
+        if (typeof wrappedResponse.data === "string") {
+          // If data is a string, parse it (shouldn't happen but defensive)
+          try {
+            dataToValidate = JSON.parse(wrappedResponse.data) as Record<
+              string,
+              unknown
+            >;
+          } catch (parseError) {
+            throw new AgentShieldAPIError(
+              "invalid_response",
+              "Failed to parse response data",
+              {
+                parseError:
+                  parseError instanceof Error
+                    ? parseError.message
+                    : String(parseError),
+              }
+            );
+          }
+        } else if (
+          typeof wrappedResponse.data === "object" &&
+          wrappedResponse.data !== null
+        ) {
+          dataToValidate = wrappedResponse.data as Record<string, unknown>;
+        } else {
+          throw new AgentShieldAPIError(
+            "invalid_response",
+            "Response data is not an object",
+            {
+              dataType: typeof wrappedResponse.data,
+              data: wrappedResponse.data,
+            }
+          );
+        }
+
         // CRITICAL: Log the actual data structure for debugging
         console.error(`[AccessControl] 🔍 DATA OBJECT STRUCTURE:`, {
           correlationId,
           dataKeys: Object.keys(dataToValidate),
-          hasAccepted: 'accepted' in dataToValidate,
-          hasRejected: 'rejected' in dataToValidate,
-          hasOutcomes: 'outcomes' in dataToValidate,
-          hasErrors: 'errors' in dataToValidate,
+          hasAccepted: "accepted" in dataToValidate,
+          hasRejected: "rejected" in dataToValidate,
+          hasOutcomes: "outcomes" in dataToValidate,
+          hasErrors: "errors" in dataToValidate,
           acceptedType: typeof dataToValidate.accepted,
+          acceptedValue: dataToValidate.accepted,
           rejectedType: typeof dataToValidate.rejected,
+          rejectedValue: dataToValidate.rejected,
           outcomesType: typeof dataToValidate.outcomes,
+          outcomesValue: dataToValidate.outcomes,
           errorsType: typeof dataToValidate.errors,
           errorsIsArray: Array.isArray(dataToValidate.errors),
           fullData: JSON.stringify(dataToValidate, null, 2),
         });
-        
+
         // Ensure success field is present (required by schema)
         // wrappedResponse.success should be true since we checked it exists
-        const dataWithSuccess = {
-          ...dataToValidate,
-          success: wrappedResponse.success === true, // Explicitly use wrapped success value
+        // CRITICAL: Explicitly construct the object to ensure all fields are present
+        // Don't rely on spread operator which might fail with Proxies or non-enumerable properties
+        const dataWithSuccess: Record<string, unknown> = {
+          success: wrappedResponse.success === true,
+          accepted: dataToValidate.accepted,
+          rejected: dataToValidate.rejected,
         };
 
+        // Add optional fields if present
+        if (
+          "outcomes" in dataToValidate &&
+          dataToValidate.outcomes !== undefined
+        ) {
+          dataWithSuccess.outcomes = dataToValidate.outcomes;
+        }
+        if ("errors" in dataToValidate && dataToValidate.errors !== undefined) {
+          dataWithSuccess.errors = dataToValidate.errors;
+        }
+
+        // CRITICAL: Log what we're validating
+        console.error(`[AccessControl] 🔍 VALIDATING DATA WITH SUCCESS:`, {
+          correlationId,
+          dataWithSuccessKeys: Object.keys(dataWithSuccess),
+          hasSuccess: "success" in dataWithSuccess,
+          successValue: dataWithSuccess.success,
+          hasAccepted: "accepted" in dataWithSuccess,
+          acceptedValue: dataWithSuccess.accepted,
+          hasRejected: "rejected" in dataWithSuccess,
+          rejectedValue: dataWithSuccess.rejected,
+          hasOutcomes: "outcomes" in dataWithSuccess,
+          outcomesValue: dataWithSuccess.outcomes,
+          fullDataWithSuccess: JSON.stringify(dataWithSuccess, null, 2),
+        });
+
+        // CRITICAL: Ensure all required fields are present before validation
+        if (
+          typeof dataWithSuccess.accepted !== "number" ||
+          typeof dataWithSuccess.rejected !== "number"
+        ) {
+          console.error(
+            `[AccessControl] ❌ MISSING REQUIRED FIELDS AFTER CONSTRUCTION:`,
+            {
+              correlationId,
+              hasAccepted: "accepted" in dataWithSuccess,
+              acceptedType: typeof dataWithSuccess.accepted,
+              acceptedValue: dataWithSuccess.accepted,
+              hasRejected: "rejected" in dataWithSuccess,
+              rejectedType: typeof dataWithSuccess.rejected,
+              rejectedValue: dataWithSuccess.rejected,
+              dataWithSuccessKeys: Object.keys(dataWithSuccess),
+              fullDataWithSuccess: JSON.stringify(dataWithSuccess, null, 2),
+              dataToValidateKeys: Object.keys(dataToValidate),
+              fullDataToValidate: JSON.stringify(dataToValidate, null, 2),
+              originalResponseData: JSON.stringify(responseData, null, 2),
+            }
+          );
+          throw new AgentShieldAPIError(
+            "invalid_response",
+            "Response data missing required fields (accepted/rejected)",
+            {
+              responseData,
+              dataToValidate,
+              dataWithSuccess,
+            }
+          );
+        }
+
         const dataParsed =
           proofSubmissionResponseSchema.safeParse(dataWithSuccess);
         if (dataParsed.success) {
@@ -561,6 +663,7 @@ export class AccessControlApiService {
               2000
             ),
             dataKeys: Object.keys(dataToValidate),
+            dataWithSuccessKeys: Object.keys(dataWithSuccess),
             originalResponse: JSON.stringify(responseData, null, 2).substring(
               0,
               2000
@@ -579,22 +682,25 @@ export class AccessControlApiService {
             `[AccessControl] Original wrapped response:`,
             JSON.stringify(responseData, null, 2)
           );
-          
+
           // CRITICAL: Log each zod error individually for easier debugging
           console.error(
             `[AccessControl] ❌ ZOD VALIDATION FAILED - ${dataParsed.error.errors.length} error(s):`
           );
           dataParsed.error.errors.forEach((err, idx) => {
             const errorDetails: Record<string, unknown> = {
-              path: err.path.join('.') || '(root)',
+              path: err.path.join(".") || "(root)",
               message: err.message,
               code: err.code,
             };
             // Only include properties that exist on specific error types
-            if ('received' in err) errorDetails.received = err.received;
-            if ('expected' in err) errorDetails.expected = err.expected;
-            if ('input' in err) errorDetails.input = err.input;
-            console.error(`[AccessControl] Error ${idx + 1}:`, errorDetails);
+            if ("received" in err) errorDetails.received = err.received;
+            if ("expected" in err) errorDetails.expected = err.expected;
+            if ("input" in err) errorDetails.input = err.input;
+            console.error(
+              `[AccessControl] Error ${idx + 1}:`,
+              JSON.stringify(errorDetails, null, 2)
+            );
           });
           console.error(
             `[AccessControl] ❌ Full ZOD errors JSON:`,
@@ -633,33 +739,30 @@ export class AccessControlApiService {
         // CRITICAL: Log to console.error with full details for debugging
         // This format matches test expectations: single call with message and error object
         // This log must include 'Response validation failed' in the message for test compatibility
-        console.error(
-          `[AccessControl] Response validation failed`,
-          {
-            zodErrors: parsed.error.errors,
-            responseData: responseData,
-          }
-        );
+        console.error(`[AccessControl] Response validation failed`, {
+          zodErrors: parsed.error.errors,
+          responseData: responseData,
+        });
         // Additional detailed logging for debugging
         console.error(
           `[AccessControl] Response validation failed`,
           validationErrorLog
         );
-        
+
         // CRITICAL: Log each zod error individually for easier debugging
         console.error(
           `[AccessControl] ❌ ZOD VALIDATION FAILED (direct) - ${parsed.error.errors.length} error(s):`
         );
         parsed.error.errors.forEach((err, idx) => {
           const errorDetails: Record<string, unknown> = {
-            path: err.path.join('.') || '(root)',
+            path: err.path.join(".") || "(root)",
             message: err.message,
             code: err.code,
           };
           // Only include properties that exist on specific error types
-          if ('received' in err) errorDetails.received = err.received;
-          if ('expected' in err) errorDetails.expected = err.expected;
-          if ('input' in err) errorDetails.input = err.input;
+          if ("received" in err) errorDetails.received = err.received;
+          if ("expected" in err) errorDetails.expected = err.expected;
+          if ("input" in err) errorDetails.input = err.input;
           console.error(`[AccessControl] Error ${idx + 1}:`, errorDetails);
         });
         console.error(