Fix VCRConfig after restack: remove filter_headers and fix match_on

Author: koxudaxi

python/tests/e2e/conftest.py

@@ -6,17 +6,18 @@
 from __future__ import annotations
 
 import hashlib
-from collections.abc import Generator
+import inspect
+from collections.abc import Awaitable, Callable, Generator
 from copy import deepcopy
-from typing import Any, TypeAlias, TypedDict, get_args
-from collections.abc import Callable
-from copy import deepcopy
-from typing import Any, TypedDict, get_args
+from typing import TypedDict, get_args
+from typing_extensions import TypeIs
 
 import httpx
 import pytest
 from anthropic.lib.bedrock import _auth as bedrock_auth
 from anthropic.lib.bedrock._client import AnthropicBedrock, AsyncAnthropicBedrock
+from vcr.cassette import Cassette as VCRCassette
+from vcr.request import Request as VCRRequest
 from vcr.stubs import httpx_stubs
 
 from mirascope import llm
@@ -74,17 +75,28 @@ class VCRConfig(TypedDict, total=False):
     - 'uri': Request URI/URL
     - 'body': Request body content (use 'raw_body' for exact binary matching)
     - 'headers': Request headers
+    - 'scheme', 'host', 'port', 'path', 'query': URL components
     """
 
-    before_record_request: Callable[[Any], Any]
-    """Callback to sanitize requests before saving to cassette.
+    filter_headers: list[str]
+    """Headers to filter out from recordings for security/privacy.
 
-    This function is called AFTER the real HTTP request is sent (with valid auth),
-    but BEFORE it's written to the cassette file. Use this to sanitize sensitive
-    headers without affecting the actual HTTP requests.
+    DEPRECATED: Use before_record_request instead for better control.
+    These headers will be removed from both recorded cassettes and
+    when matching requests during playback. Commonly used for:
+    - Authentication tokens
+    - API keys
+    - Organization identifiers
+    """
+
+    filter_post_data_parameters: list[str]
+    """POST data parameters to filter out from recordings.
+
+    Similar to filter_headers but for form data and request body parameters.
+    Useful for removing sensitive data from request bodies.
     """
 
-    before_record_request: Any
+    before_record_request: Callable[[VCRRequest], VCRRequest]
     """Callback to sanitize requests before saving to cassette.
 
     This function is called AFTER the real HTTP request is sent (with valid auth),
@@ -101,17 +113,15 @@ class VCRConfig(TypedDict, total=False):
     """
 
 
-
-def sanitize_request(request: Any) -> Any:  # noqa: ANN401
+def sanitize_request(request: VCRRequest) -> VCRRequest:
     """Sanitize sensitive headers in VCR request before recording to cassette.
 
     This hook is called AFTER the real HTTP request is sent (with valid auth),
     but BEFORE it's written to the cassette file. We deep copy the request
     and replace sensitive headers with placeholders.
 
     Args:
-        request: VCR request object to sanitize (Any type since VCR doesn't
-            provide typed request objects)
+        request: VCR request object to sanitize
 
     Returns:
         Sanitized copy of the request safe for cassette storage
@@ -151,17 +161,14 @@ def vcr_config() -> VCRConfig:
     """
     return {
         "record_mode": "once",
-        "match_on": ["method", "scheme", "host", "port", "path", "query", "raw_body"],
+        "match_on": ["method", "uri", "body"],
         "filter_headers": [],  # Don't filter here; use before_record_request
         "filter_post_data_parameters": [],
         "before_record_request": sanitize_request,
         "decode_compressed_response": False,  # Preserve exact response bytes
     }
 
 
-Snapshot: TypeAlias = Any  # Alias to avoid Ruff lint errors
-
-
 def _remove_auth_headers(headers: httpx.Headers) -> None:
     """Remove stale AWS authentication headers before re-signing.
 
@@ -286,7 +293,7 @@ async def _resign_async() -> None:
     original_sync_send = httpx_stubs._sync_vcr_send
     original_async_send = httpx_stubs._async_vcr_send
 
-    def _is_bedrock_request(request: httpx.Request | None) -> bool:
+    def _is_bedrock_request(request: httpx.Request | None) -> TypeIs[httpx.Request]:
         """Check if the request is targeting AWS Bedrock API.
 
         We identify Bedrock requests by checking for 'bedrock-runtime' in the
@@ -338,7 +345,7 @@ def _handle_bedrock_resign_sync(real_request: httpx.Request) -> None:
         _reset_request_body(real_request, body_bytes)
 
         resign_sync = real_request.extensions.get("mirascope_bedrock_resign")
-        if callable(resign_sync):
+        if inspect.isfunction(resign_sync):
             _remove_auth_headers(real_request.headers)
             resign_sync()
             _reset_request_body(real_request, body_bytes)
@@ -358,21 +365,27 @@ async def _handle_bedrock_resign_async(real_request: httpx.Request) -> None:
         resign_async = real_request.extensions.get("mirascope_bedrock_resign_async")
         resign_sync = real_request.extensions.get("mirascope_bedrock_resign")
 
-        if callable(resign_async):
+        if inspect.iscoroutinefunction(resign_async):
             _remove_auth_headers(real_request.headers)
             await resign_async()
             _reset_request_body(real_request, body_bytes)
-        elif callable(resign_sync):
+        elif inspect.isfunction(resign_sync):
             _remove_auth_headers(real_request.headers)
             resign_sync()
             _reset_request_body(real_request, body_bytes)
 
-    def _patched_sync_send(cassette, real_send, *args, **kwargs) -> httpx.Response:  # noqa: ANN001, ANN002, ANN003
+    def _patched_sync_send(
+        cassette: VCRCassette,
+        real_send: Callable[..., httpx.Response],
+        client: httpx.Client,
+        request: httpx.Request,
+        **kwargs: object,
+    ) -> httpx.Response:
+        args = (client, request)
         vcr_request, response = original_shared_send(
             cassette, real_send, *args, **kwargs
         )
-        client = args[0]
-        real_request = args[1] if len(args) > 1 else None
+        real_request: httpx.Request | None = request
 
         if response is not None:
             client.cookies.extract_cookies(response)
@@ -392,16 +405,18 @@ def _patched_sync_send(cassette, real_send, *args, **kwargs) -> httpx.Response:
         return real_response
 
     async def _patched_async_send(
-        cassette,
-        real_send,
-        *args,
-        **kwargs,  # noqa: ANN001, ANN002, ANN003
+        cassette: VCRCassette,
+        real_send: Callable[..., Awaitable[httpx.Response]],
+        client: httpx.AsyncClient,
+        request: httpx.Request,
+        **kwargs: object,
     ) -> httpx.Response:
+        # VCR expects args tuple, so reconstruct it for original_shared_send
+        args = (client, request)
         vcr_request, response = original_shared_send(
             cassette, real_send, *args, **kwargs
         )
-        client = args[0]
-        real_request = args[1] if len(args) > 1 else None
+        real_request: httpx.Request | None = request
 
         if response is not None:
             client.cookies.extract_cookies(response)