refactor!: migrate HTTP client from requests to httpx

Replace the synchronous HTTP client library from `requests` to `httpx`
for improved async support potential and modern API design.

Changes include:
- Replace `requests>=2.32.3` with `httpx>=0.28.0` in dependencies
- Update `stackone_ai/models.py` to use httpx.request() instead of
  requests.request()
- Refactor exception handling to use httpx-specific exceptions:
  - httpx.HTTPStatusError for HTTP error responses
  - httpx.RequestError for connection/network errors
- Replace test mocking library from `responses` to `respx`
- Remove `types-requests` type stubs (no longer needed)
- Update all test files to use respx decorators and httpx.Response

BREAKING CHANGE: Error handling now uses httpx exceptions instead of
requests exceptions. Code catching RequestException should be updated
to catch httpx.HTTPStatusError or httpx.RequestError.

Author: ryoppippi

pyproject.toml

@@ -21,7 +21,7 @@ classifiers = [
 ]
 dependencies = [
     "pydantic>=2.10.6",
-    "requests>=2.32.3",
+    "httpx>=0.28.0",
     "langchain-core>=0.1.0",
     "bm25s>=0.2.2",
     "numpy>=1.24.0",
@@ -62,10 +62,9 @@ dev = [
     "pytest-asyncio>=0.25.3",
     "pytest-cov>=6.0.0",
     "pytest-snapshot>=0.9.0",
-    "responses>=0.25.8",
+    "respx>=0.22.0",
     "ruff>=0.9.6",
     "stackone-ai",
-    "types-requests>=2.31.0.20240311",
 ]
 
 [tool.pytest.ini_options]

stackone_ai/models.py

@@ -10,10 +10,9 @@
 from typing import Annotated, Any, ClassVar, cast
 from urllib.parse import quote
 
-import requests
+import httpx
 from langchain_core.tools import BaseTool
 from pydantic import BaseModel, BeforeValidator, Field, PrivateAttr
-from requests.exceptions import RequestException
 
 # TODO: Remove when Python 3.9 support is dropped
 from typing_extensions import TypeAlias
@@ -242,7 +241,7 @@ def execute(
             if query_params:
                 request_kwargs["params"] = query_params
 
-            response = requests.request(**request_kwargs)
+            response = httpx.request(**request_kwargs)
             response_status = response.status_code
             response.raise_for_status()
 
@@ -254,15 +253,23 @@ def execute(
             status = "error"
             error_message = f"Invalid JSON in arguments: {exc}"
             raise ValueError(error_message) from exc
-        except RequestException as exc:
+        except httpx.HTTPStatusError as exc:
+            status = "error"
+            error_message = str(exc)
+            response_body = None
+            if exc.response.text:
+                try:
+                    response_body = exc.response.json()
+                except json.JSONDecodeError:
+                    response_body = exc.response.text
+            raise StackOneAPIError(
+                str(exc),
+                exc.response.status_code,
+                response_body,
+            ) from exc
+        except httpx.RequestError as exc:
             status = "error"
             error_message = str(exc)
-            if hasattr(exc, "response") and exc.response is not None:
-                raise StackOneAPIError(
-                    str(exc),
-                    exc.response.status_code,
-                    exc.response.json() if exc.response.text else None,
-                ) from exc
             raise StackOneError(f"Request failed: {exc}") from exc
         finally:
             datetime.now(timezone.utc)

tests/test_feedback.py

@@ -5,9 +5,10 @@
 
 import json
 import os
-from unittest.mock import Mock, patch
 
+import httpx
 import pytest
+import respx
 
 from stackone_ai.feedback import create_feedback_tool
 from stackone_ai.models import StackOneError
@@ -55,165 +56,150 @@ def test_multiple_account_ids_validation(self) -> None:
         with pytest.raises(StackOneError, match="At least one valid account ID is required"):
             tool.execute({"feedback": "Great tools!", "account_id": ["", "   "], "tool_names": ["test_tool"]})
 
+    @respx.mock
     def test_json_string_input(self) -> None:
         """Test that JSON string input is properly parsed."""
         tool = create_feedback_tool(api_key="test_key")
 
-        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
+        route = respx.post("https://api.stackone.com/ai/tool-feedback").mock(
+            return_value=httpx.Response(200, json={"message": "Success"})
+        )
 
-            json_string = json.dumps(
-                {"feedback": "Great tools!", "account_id": "acc_123456", "tool_names": ["test_tool"]}
-            )
-            result = tool.execute(json_string)
-            assert result["message"] == "Success"
+        json_string = json.dumps(
+            {"feedback": "Great tools!", "account_id": "acc_123456", "tool_names": ["test_tool"]}
+        )
+        result = tool.execute(json_string)
+        assert result["message"] == "Success"
+        assert route.called
 
 
 class TestFeedbackToolExecution:
     """Test suite for feedback tool execution."""
 
+    @respx.mock
     def test_single_account_execution(self) -> None:
         """Test execution with single account ID."""
         tool = create_feedback_tool(api_key="test_key")
         api_response = {"message": "Feedback successfully stored", "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",
-                    "tool_names": ["data_export", "analytics"],
-                }
-            )
-
-            assert result == api_response
-            mock_request.assert_called_once()
-            call_kwargs = mock_request.call_args[1]
-            assert call_kwargs["method"] == "POST"
-            assert call_kwargs["url"] == "https://api.stackone.com/ai/tool-feedback"
-            assert call_kwargs["json"]["feedback"] == "Great tools!"
-            assert call_kwargs["json"]["account_id"] == "acc_123456"
-            assert call_kwargs["json"]["tool_names"] == ["data_export", "analytics"]
-
+        route = respx.post("https://api.stackone.com/ai/tool-feedback").mock(
+            return_value=httpx.Response(200, json=api_response)
+        )
+
+        result = tool.execute(
+            {
+                "feedback": "Great tools!",
+                "account_id": "acc_123456",
+                "tool_names": ["data_export", "analytics"],
+            }
+        )
+
+        assert result == api_response
+        assert route.called
+        assert route.call_count == 1
+        request = route.calls[0].request
+        body = json.loads(request.content)
+        assert body["feedback"] == "Great tools!"
+        assert body["account_id"] == "acc_123456"
+        assert body["tool_names"] == ["data_export", "analytics"]
+
+    @respx.mock
     def test_call_method_interface(self) -> None:
         """Test that the .call() method works correctly."""
         tool = create_feedback_tool(api_key="test_key")
         api_response = {"message": "Success", "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.call(
-                feedback="Testing the .call() method interface.",
-                account_id="acc_test004",
-                tool_names=["meta_collect_tool_feedback"],
-            )
+        route = respx.post("https://api.stackone.com/ai/tool-feedback").mock(
+            return_value=httpx.Response(200, json=api_response)
+        )
 
-            assert result == api_response
-            mock_request.assert_called_once()
+        result = tool.call(
+            feedback="Testing the .call() method interface.",
+            account_id="acc_test004",
+            tool_names=["meta_collect_tool_feedback"],
+        )
 
+        assert result == api_response
+        assert route.called
+        assert route.call_count == 1
+
+    @respx.mock
     def test_api_error_handling(self) -> None:
         """Test that API errors are handled properly."""
         tool = create_feedback_tool(api_key="test_key")
 
-        with patch("requests.request") as mock_request:
-            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")
-            mock_request.return_value = mock_response
-
-            with pytest.raises(StackOneError):
-                tool.execute(
-                    {
-                        "feedback": "Great tools!",
-                        "account_id": "acc_123456",
-                        "tool_names": ["test_tool"],
-                    }
-                )
-
-    def test_multiple_account_ids_execution(self) -> None:
-        """Test execution with multiple account IDs - both success and mixed scenarios."""
-        tool = create_feedback_tool(api_key="test_key")
-        api_response = {"message": "Feedback successfully stored", "trace_id": "test-trace-id"}
+        respx.post("https://api.stackone.com/ai/tool-feedback").mock(
+            return_value=httpx.Response(401, json={"error": "Unauthorized"})
+        )
 
-        # Test all successful case
-        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(
+        with pytest.raises(StackOneError):
+            tool.execute(
                 {
                     "feedback": "Great tools!",
-                    "account_id": ["acc_123456", "acc_789012", "acc_345678"],
+                    "account_id": "acc_123456",
                     "tool_names": ["test_tool"],
                 }
             )
 
-            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
-            assert mock_request.call_count == 3
+    @respx.mock
+    def test_multiple_account_ids_execution(self) -> None:
+        """Test execution with multiple account IDs - both success and mixed scenarios."""
+        tool = create_feedback_tool(api_key="test_key")
+        api_response = {"message": "Feedback successfully stored", "trace_id": "test-trace-id"}
 
-        # Test mixed success/error case
-        def mock_request_side_effect(*args, **kwargs):
-            account_id = kwargs.get("json", {}).get("account_id")
+        # Test all successful case
+        route = respx.post("https://api.stackone.com/ai/tool-feedback").mock(
+            return_value=httpx.Response(200, json=api_response)
+        )
+
+        result = tool.execute(
+            {
+                "feedback": "Great tools!",
+                "account_id": ["acc_123456", "acc_789012", "acc_345678"],
+                "tool_names": ["test_tool"],
+            }
+        )
+
+        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
+        assert route.call_count == 3
+
+    @respx.mock
+    def test_multiple_account_ids_mixed_success(self) -> None:
+        """Test execution with multiple account IDs - mixed success and error."""
+        tool = create_feedback_tool(api_key="test_key")
+
+        def custom_side_effect(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            account_id = body.get("account_id")
             if account_id == "acc_123456":
-                mock_response = Mock()
-                mock_response.status_code = 200
-                mock_response.json.return_value = {"message": "Success"}
-                mock_response.raise_for_status = Mock()
-                return mock_response
+                return httpx.Response(200, json={"message": "Success"})
             else:
-                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
+                return httpx.Response(401, json={"error": "Unauthorized"})
 
-        with patch("requests.request") as mock_request:
-            mock_request.side_effect = mock_request_side_effect
+        respx.post("https://api.stackone.com/ai/tool-feedback").mock(side_effect=custom_side_effect)
 
-            result = tool.execute(
-                {
-                    "feedback": "Great tools!",
-                    "account_id": ["acc_123456", "acc_unauthorized"],
-                    "tool_names": ["test_tool"],
-                }
-            )
+        result = tool.execute(
+            {
+                "feedback": "Great tools!",
+                "account_id": ["acc_123456", "acc_unauthorized"],
+                "tool_names": ["test_tool"],
+            }
+        )
 
-            assert result["total_accounts"] == 2
-            assert result["successful"] == 1
-            assert result["failed"] == 1
-            assert len(result["results"]) == 2
+        assert result["total_accounts"] == 2
+        assert result["successful"] == 1
+        assert result["failed"] == 1
+        assert len(result["results"]) == 2
 
-            success_result = next(r for r in result["results"] if r["account_id"] == "acc_123456")
-            assert success_result["status"] == "success"
+        success_result = next(r for r in result["results"] if r["account_id"] == "acc_123456")
+        assert success_result["status"] == "success"
 
-            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"]
+        error_result = next(r for r in result["results"] if r["account_id"] == "acc_unauthorized")
+        assert error_result["status"] == "error"
 
     def test_tool_integration(self) -> None:
         """Test that feedback tool integrates properly with toolset."""

tests/test_meta_tools.py

@@ -1,7 +1,8 @@
 """Tests for meta tools functionality"""
 
+import httpx
 import pytest
-import responses
+import respx
 
 from stackone_ai import StackOneTool, Tools
 from stackone_ai.meta_tools import (
@@ -209,24 +210,22 @@ def test_execute_tool_invalid_name(self, tools_collection):
                 }
             )
 
+    @respx.mock
     def test_execute_tool_call(self, tools_collection):
         """Test calling the execute tool with call method"""
         execute_tool = create_meta_execute_tool(tools_collection)
 
-        # Mock the actual tool execution by patching the requests
-        with responses.RequestsMock() as rsps:
-            rsps.add(
-                responses.GET,
-                "https://api.example.com/hris/employee",
-                json={"success": True, "employees": []},
-                status=200,
-            )
+        # Mock the actual tool execution
+        route = respx.get("https://api.example.com/hris/employee").mock(
+            return_value=httpx.Response(200, json={"success": True, "employees": []})
+        )
 
-            # Call the meta execute tool
-            result = execute_tool.call(toolName="hris_list_employee", params={"limit": 10})
+        # Call the meta execute tool
+        result = execute_tool.call(toolName="hris_list_employee", params={"limit": 10})
 
-            assert result is not None
-            assert "success" in result or "employees" in result
+        assert result is not None
+        assert "success" in result or "employees" in result
+        assert route.called
 
 
 class TestToolsMetaTools: