@channel47/google-ads-mcp 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@channel47/google-ads-mcp",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Google Ads MCP Server - Query and mutate Google Ads data using GAQL",
   "main": "server/index.js",
   "bin": {

package/server/tools/mutate.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { getCustomerClient } from '../auth.js';
+import { formatSuccess, formatError } from '../utils/response-format.js';
 
 /**
  * Execute mutation operations using GoogleAdsService.Mutate
@@ -22,43 +23,105 @@ export async function mutate(params) {
 
   // Validate required parameters
   if (!customer_id) {
-    return {
-      success: false,
-      error: 'customer_id is required (either as parameter or GOOGLE_ADS_CUSTOMER_ID env var)'
-    };
+    return formatError(new Error('customer_id is required (either as parameter or GOOGLE_ADS_CUSTOMER_ID env var)'));
   }
 
   if (!operations || !Array.isArray(operations) || operations.length === 0) {
-    return {
-      success: false,
-      error: 'operations array is required and must contain at least one operation'
-    };
+    return formatError(new Error('operations array is required and must contain at least one operation'));
   }
 
-  try {
-    const customer = getCustomerClient(customer_id);
+  const customer = getCustomerClient(customer_id);
+  let response;
+  let partialFailureErrors = [];
 
+  try {
     // Execute mutation with validation options
-    const response = await customer.mutateResources(operations, {
+    response = await customer.mutateResources(operations, {
       partialFailure: partial_failure,
       validateOnly: dry_run
     });
-
-    return {
-      success: true,
-      dry_run,
-      results: response,
-      message: dry_run
-        ? 'Validation successful - no changes made'
-        : 'Mutations applied successfully',
-      operations_count: operations.length
-    };
   } catch (error) {
+    // The Opteo library throws exceptions with error.errors array for partial failures
+    // Extract failure details if available
+    if (partial_failure && error.errors && Array.isArray(error.errors)) {
+      for (const err of error.errors) {
+        const opIndex = err.location?.field_path_elements?.[0]?.index ?? -1;
+        partialFailureErrors.push({
+          message: err.message || JSON.stringify(err.error_code),
+          error_code: err.error_code,
+          operation_index: opIndex
+        });
+      }
+
+      // If not all operations failed, treat as partial success
+      if (partialFailureErrors.length < operations.length) {
+        response = { mutate_operation_responses: [], partial_failure_error: null };
+      } else {
+        // All operations failed
+        const errorMessages = partialFailureErrors.map(e => e.message).join('; ');
+        return formatError(new Error(`All operations failed: ${errorMessages}`));
+      }
+    } else {
+      // Not a partial failure - re-throw as regular error
+      return formatError(error);
+    }
+  }
+
+  // Extract results from response
+  const results = response.mutate_operation_responses || [];
+
+  // Check for partial failure errors in response body (alternative structure)
+  if (response.partial_failure_error) {
+    const errorDetails = response.partial_failure_error.errors
+      || response.partial_failure_error.details
+      || [];
+
+    for (const error of errorDetails) {
+      partialFailureErrors.push({
+        message: error.message || error.error_message || JSON.stringify(error),
+        error_code: error.error_code || error.code,
+        operation_index: error.location?.field_path_elements?.[0]?.index ?? -1
+      });
+    }
+  }
+
+  // Calculate success/failure counts
+  const failCount = partialFailureErrors.length;
+  const successCount = operations.length - failCount;
+
+  // Extract resource names from nested result structure
+  // Results come as: { campaign_result: { resource_name: "..." }, response: "campaign_result" }
+  const extractedResults = results.map(r => {
+    // Find the result field (campaign_result, ad_group_result, etc.)
+    const resultKey = r?.response;
+    const resultData = resultKey ? r[resultKey] : r;
     return {
-      success: false,
-      dry_run,
-      error: error.message,
-      error_details: error.errors || null
+      resource_name: resultData?.resource_name || null
     };
+  });
+
+  // Build appropriate message
+  let message;
+  if (dry_run) {
+    message = failCount > 0
+      ? `Validation completed with ${failCount} error(s) - no changes made`
+      : 'Validation successful - no changes made';
+  } else {
+    message = failCount > 0
+      ? `Mutations completed: ${successCount} succeeded, ${failCount} failed`
+      : 'Mutations applied successfully';
   }
+
+  return formatSuccess({
+    summary: `${message} (${operations.length} operation${operations.length !== 1 ? 's' : ''})`,
+    data: extractedResults,
+    metadata: {
+      dry_run,
+      operations_count: operations.length,
+      success_count: successCount,
+      failure_count: failCount,
+      customer_id,
+      ...(partialFailureErrors.length > 0 && { errors: partialFailureErrors })
+    }
+  });
 }