feat: support multiple account IDs in feedback tool

- Allow account_id to be string or list of strings
- Send same feedback to each account individually
- Return combined results with success/failure counts
- Add comprehensive tests for validation and execution
- All 9 tests passing, linting clean

Author: NicolasBelissent

stackone_ai/feedback/tool.py

@@ -21,18 +21,38 @@ class FeedbackInput(BaseModel):
     """Input schema for feedback tool."""
 
     feedback: str = Field(..., min_length=1, description="User feedback text")
-    account_id: str = Field(..., min_length=1, description="Account identifier")
+    account_id: str | list[str] = Field(..., description="Account identifier(s) - single ID or list of IDs")
     tool_names: list[str] = Field(..., min_length=1, description="List of tool names")
 
-    @field_validator("feedback", "account_id")
+    @field_validator("feedback")
     @classmethod
-    def validate_non_empty_trimmed(cls, v: str) -> str:
-        """Validate that string is non-empty after trimming."""
+    def validate_feedback(cls, v: str) -> str:
+        """Validate that feedback is non-empty after trimming."""
         trimmed = v.strip()
         if not trimmed:
-            raise ValueError("Field must be a non-empty string")
+            raise ValueError("Feedback must be a non-empty string")
         return trimmed
 
+    @field_validator("account_id")
+    @classmethod
+    def validate_account_id(cls, v: str | list[str]) -> list[str]:
+        """Validate and normalize account ID(s) to a list."""
+        if isinstance(v, str):
+            trimmed = v.strip()
+            if not trimmed:
+                raise ValueError("Account ID must be a non-empty string")
+            return [trimmed]
+
+        if isinstance(v, list):
+            if not v:
+                raise ValueError("At least one account ID is required")
+            cleaned = [str(item).strip() for item in v if str(item).strip()]
+            if not cleaned:
+                raise ValueError("At least one valid account ID is required")
+            return cleaned
+
+        raise ValueError("Account ID must be a string or list of strings")
+
     @field_validator("tool_names")
     @classmethod
     def validate_tool_names(cls, v: list[str]) -> list[str]:
@@ -52,12 +72,14 @@ def execute(
         """
         Execute the feedback tool with enhanced validation.
 
+        If multiple account IDs are provided, sends the same feedback to each account individually.
+
         Args:
             arguments: Tool arguments as string or dict
             options: Execution options
 
         Returns:
-            Response from the API
+            Combined response from all API calls
 
         Raises:
             StackOneError: If validation or API call fails
@@ -72,16 +94,59 @@ def execute(
             # Validate with Pydantic
             parsed_params = FeedbackInput(**raw_params)
 
-            # Build validated request body
-            validated_arguments = {
-                "feedback": parsed_params.feedback,
-                "account_id": parsed_params.account_id,
-                "tool_names": parsed_params.tool_names,
+            # Get list of account IDs (already normalized by validator)
+            account_ids = parsed_params.account_id
+            feedback = parsed_params.feedback
+            tool_names = parsed_params.tool_names
+
+            # If only one account ID, use the parent execute method
+            if len(account_ids) == 1:
+                validated_arguments = {
+                    "feedback": feedback,
+                    "account_id": account_ids[0],
+                    "tool_names": tool_names,
+                }
+                return super().execute(validated_arguments, options=options)
+
+            # Multiple account IDs - send to each individually
+            results = []
+            errors = []
+
+            for account_id in account_ids:
+                try:
+                    validated_arguments = {
+                        "feedback": feedback,
+                        "account_id": account_id,
+                        "tool_names": tool_names,
+                    }
+                    result = super().execute(validated_arguments, options=options)
+                    results.append({
+                        "account_id": account_id,
+                        "status": "success",
+                        "result": result
+                    })
+                except Exception as exc:
+                    error_msg = str(exc)
+                    errors.append({
+                        "account_id": account_id,
+                        "status": "error",
+                        "error": error_msg
+                    })
+                    results.append({
+                        "account_id": account_id,
+                        "status": "error",
+                        "error": error_msg
+                    })
+
+            # Return combined results
+            return {
+                "message": f"Feedback sent to {len(account_ids)} account(s)",
+                "total_accounts": len(account_ids),
+                "successful": len([r for r in results if r["status"] == "success"]),
+                "failed": len(errors),
+                "results": results
             }
 
-            # Use the parent execute method with validated arguments
-            return super().execute(validated_arguments, options=options)
-
         except json.JSONDecodeError as exc:
             raise StackOneError(f"Invalid JSON in arguments: {exc}") from exc
         except ValueError as exc:
@@ -120,8 +185,18 @@ def create_feedback_tool(
         type="object",
         properties={
             "account_id": {
-                "type": "string",
-                "description": 'Account identifier (e.g., "acc_123456")',
+                "oneOf": [
+                    {
+                        "type": "string",
+                        "description": 'Single account identifier (e.g., "acc_123456")',
+                    },
+                    {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "List of account identifiers for multiple accounts",
+                    },
+                ],
+                "description": "Account identifier(s) - single ID or list of IDs",
             },
             "feedback": {
                 "type": "string",

tests/test_feedback.py

@@ -57,6 +57,34 @@ def test_validation_errors(self) -> None:
             result = tool.execute(json_string)
             assert result["message"] == "Success"
 
+    def test_multiple_account_ids_validation(self) -> None:
+        """Test validation with multiple account IDs."""
+        tool = create_feedback_tool(api_key="test_key")
+
+        # Test empty account ID list
+        with pytest.raises(StackOneError, match="At least one account ID is required"):
+            tool.execute({"feedback": "Great tools!", "account_id": [], "tool_names": ["test_tool"]})
+
+        # Test account ID list with empty strings
+        with pytest.raises(StackOneError, match="At least one valid account ID is required"):
+            tool.execute({"feedback": "Great tools!", "account_id": ["", "   "], "tool_names": ["test_tool"]})
+
+        # Test valid multiple account IDs
+        with patch("requests.request") as mock_request:
+            mock_response = Mock()
+            mock_response.status_code = 200
+            mock_response.json.return_value = {"message": "Success"}
+            mock_response.raise_for_status = Mock()
+            mock_request.return_value = mock_response
+
+            result = tool.execute({
+                "feedback": "Great tools!",
+                "account_id": ["acc_123456", "acc_789012"],
+                "tool_names": ["test_tool"]
+            })
+            assert "total_accounts" in result
+            assert result["total_accounts"] == 2
+
 
 class TestFeedbackToolExecution:
     """Test suite for feedback tool execution."""
@@ -151,6 +179,94 @@ def test_handles_api_errors(self) -> None:
                     }
                 )
 
+    def test_multiple_account_ids_execution(self) -> None:
+        """Test execution with multiple account IDs."""
+        tool = create_feedback_tool(api_key="test_key")
+
+        api_response = {
+            "message": "Feedback successfully stored",
+            "key": "test-key.json",
+            "submitted_at": "2025-10-08T11:44:16.123Z",
+            "trace_id": "test-trace-id",
+        }
+
+        with patch("requests.request") as mock_request:
+            mock_response = Mock()
+            mock_response.status_code = 200
+            mock_response.json.return_value = api_response
+            mock_response.raise_for_status = Mock()
+            mock_request.return_value = mock_response
+
+            result = tool.execute({
+                "feedback": "Great tools!",
+                "account_id": ["acc_123456", "acc_789012", "acc_345678"],
+                "tool_names": ["test_tool"]
+            })
+
+            # Check combined result structure
+            assert result["message"] == "Feedback sent to 3 account(s)"
+            assert result["total_accounts"] == 3
+            assert result["successful"] == 3
+            assert result["failed"] == 0
+            assert len(result["results"]) == 3
+
+            # Check individual results
+            for i, account_id in enumerate(["acc_123456", "acc_789012", "acc_345678"]):
+                assert result["results"][i]["account_id"] == account_id
+                assert result["results"][i]["status"] == "success"
+                assert result["results"][i]["result"] == api_response
+
+            # Verify API was called 3 times
+            assert mock_request.call_count == 3
+
+    def test_multiple_account_ids_with_errors(self) -> None:
+        """Test execution with multiple account IDs where some fail."""
+        tool = create_feedback_tool(api_key="test_key")
+
+        success_response = {"message": "Success"}
+
+        def mock_request_side_effect(*args, **kwargs):
+            account_id = kwargs.get("json", {}).get("account_id")
+            if account_id == "acc_123456":
+                # Success case
+                mock_response = Mock()
+                mock_response.status_code = 200
+                mock_response.json.return_value = success_response
+                mock_response.raise_for_status = Mock()
+                return mock_response
+            else:
+                # Error case
+                mock_response = Mock()
+                mock_response.status_code = 401
+                mock_response.text = '{"error": "Unauthorized"}'
+                mock_response.json.return_value = {"error": "Unauthorized"}
+                mock_response.raise_for_status.side_effect = Exception("401 Client Error: Unauthorized")
+                return mock_response
+
+        with patch("requests.request") as mock_request:
+            mock_request.side_effect = mock_request_side_effect
+
+            result = tool.execute({
+                "feedback": "Great tools!",
+                "account_id": ["acc_123456", "acc_unauthorized"],
+                "tool_names": ["test_tool"]
+            })
+
+            # Check combined result structure
+            assert result["total_accounts"] == 2
+            assert result["successful"] == 1
+            assert result["failed"] == 1
+            assert len(result["results"]) == 2
+
+            # Check individual results
+            success_result = next(r for r in result["results"] if r["account_id"] == "acc_123456")
+            assert success_result["status"] == "success"
+            assert success_result["result"] == success_response
+
+            error_result = next(r for r in result["results"] if r["account_id"] == "acc_unauthorized")
+            assert error_result["status"] == "error"
+            assert "401 Client Error: Unauthorized" in error_result["error"]
+
 
 class TestFeedbackToolIntegration:
     """Test suite for feedback tool integration."""