deepintshield 2.7.1__tar.gz → 2.7.2__tar.gz

{deepintshield-2.7.1/src/deepintshield.egg-info → deepintshield-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepintshield
-Version: 2.7.1
+Version: 2.7.2
 Summary: Unified Python SDK for routing chat, RAG, agentic tool-gating, identity, and MCP traffic through DeepintShield - drop-in across the top agentic frameworks.
 Author: DeepintShield
 License-Expression: Apache-2.0
@@ -98,6 +98,8 @@ Dynamic: license-file
 
 Unified Python SDK for DeepIntShield - one import, any provider, any agent framework.
 
+Current release: **2.7.2**, aligned with DeepIntShield Server **2.7.2**.
+
 `deepintshield` lets you keep writing idiomatic OpenAI / Anthropic / Bedrock /
 Google GenAI code **and** native agent-framework code (LangGraph, CrewAI,
 OpenAI Agents SDK, LlamaIndex, AutoGen, PydanticAI, Temporal, AWS Strands,
@@ -134,6 +136,9 @@ and you're done.
 
 ## Install
 
+For a reproducible installation of this release, use `pip install "deepintshield==2.7.2"`.
+Add the provider and framework extras your application needs:
+
 ```bash
 pip install deepintshield                       # core (chat, RAG, agentic)
 pip install 'deepintshield[openai]'             # + OpenAI SDK
@@ -268,17 +273,40 @@ response = openai.chat.completions.create(
 )
 ```
 
+The same client exposes the native Responses API:
+
+```python
+response = openai.responses.create(
+    model="gpt-4o-mini",
+    input="Explain this design in one sentence.",
+    store=False,
+)
+print(response.output_text)
+```
+
+Responses uses `max_output_tokens` and a `reasoning` object where supported;
+Chat Completions uses its model's supported token-limit field and
+`reasoning_effort`. For manual Responses continuations, retain the full output
+items, including tool calls and opaque reasoning state, and replay them only
+with the same provider and model. The Playground performs this mapping and
+preserves compatible response state in saved sessions.
+
 ### Anthropic
 
 ```python
 anthropic = shield.anthropic()
 response = anthropic.messages.create(
-    model="claude-3-sonnet-20240229",
+    model="claude-sonnet-5",
     max_tokens=256,
     messages=[{"role": "user", "content": "hello"}],
 )
 ```
 
+`shield.anthropic()` uses the installed Anthropic SDK's default transport class,
+including SDK releases backed by `httpx2`, and retains automatic prompt-cache
+hooks. A caller-supplied `http_client` must be compatible with that installed SDK
+and remains responsible for its own prompt-cache hooks.
+
 ### Bedrock
 
 ```python
@@ -294,11 +322,30 @@ response = bedrock.converse(
 ```python
 genai = shield.genai()
 response = genai.models.generate_content(
-    model="gemini-1.5-flash",
+    model="gemini-3.5-flash",
     contents="hello",
+    config={"automatic_function_calling": {"disable": True}},
 )
+print(response.text)
 ```
 
+Disabling automatic function calling (AFC) is optional for this text-only call.
+Recent Google SDK versions warn about direct AFC use even when no callable tools
+are supplied; that warning alone does not mean the request failed. When using
+Python callable tools, Google recommends the chat interface. Multi-turn tool
+workflows also depend on the gateway preserving tool roles and thought signatures;
+a successful text-only request does not verify those conversions.
+
+The gateway's native Gemini conversion preserves model/user tool roles, per-call
+thought signatures, and distinct IDs for parallel calls to the same function.
+SDK regression tests cover direct and chat calls, sync/async streaming, and
+callable-tool continuations. A timeout-only `http_options` override retains the
+gateway destination in SDK 2.7.2 (fixed in 2.7.1); SDK 2.7.0 does not merge that override correctly.
+
+For streaming, use `genai.models.generate_content_stream(...)` or
+`chat.send_message_stream(...)` and read each chunk's `text`. The native async
+interfaces remain available under `genai.aio`.
+
 ### LangChain
 
 ```python
@@ -370,6 +417,12 @@ retriever = shield.rag.guard_retriever(my_retriever)   # mutates in place
 docs = retriever.invoke("what is the Q2 ledger?")        # only allowed chunks
 ```
 
+Async retrievers are supported too: use `await retriever.ainvoke(query)` or
+the retriever's native async retrieval method. Filtering finishes before
+documents are returned; delegated retrieval methods filter once per call.
+Allowed documents keep their order and original framework objects. Redacted
+content is returned in copies, leaving the retriever's source documents intact.
+
 ### Guard an embedder (pre-embedding, Portkey-parity "before request")
 
 Screen input text for PII / injection / toxicity **before** it is vectorised:
@@ -808,15 +861,21 @@ OpenAI/Anthropic/LangChain conversion-loop helpers remain deprecated 2.x
 compatibility shims. Their removal is planned for SDK 3.0; new code should use
 the official session or a maintained third-party adapter.
 
+For an existing Anthropic conversion loop, use the same `shield.mcp` instance
+for `to_anthropic(tools)` and `run_anthropic_tool_uses(response.content)`.
+Provider-safe aliases distinguish qualified names that contain unsupported
+characters or exceed Anthropic's length limit; that client retains the mapping
+back to the original tool names for execution.
+
 ---
 
 ## Cost Optimization
 
-The SDK automatically participates in the gateway's two cost-reduction layers
+The SDK participates in the gateway's caching mechanisms
 (both controlled by workspace switches under **Cost Optimization**):
 
-- **Provider prompt caching** - every chat client returned by `shield.openai()`,
-  `shield.anthropic()`, etc. ships an `httpx` request hook that injects
+- **Provider prompt caching** - SDK-created OpenAI and Anthropic transports
+  include request hooks that inject
   Anthropic `cache_control` markers and an OpenAI `prompt_cache_key` so the
   provider reuses KV state for the static prompt prefix. Eligible cached tokens
   use the provider's current cached-input rate; verify model-specific pricing
@@ -830,6 +889,11 @@ The SDK automatically participates in the gateway's two cost-reduction layers
   threshold. The SDK doesn't need any code change to benefit; results flow
   back through the normal API.
 
+Cost dashboards show recorded numeric totals, using `$0.00` when no display
+value is available. Missing prices remain nullable in API log records and can
+still be found through the missing-cost filter. Estimated savings remain signed
+and are separate from the actual recorded cost.
+
 ### Per-request cache overrides
 
 Workspace settings are the default, but any individual call can override

{deepintshield-2.7.1 → deepintshield-2.7.2}/README.md

@@ -5,6 +5,8 @@
 
 Unified Python SDK for DeepIntShield - one import, any provider, any agent framework.
 
+Current release: **2.7.2**, aligned with DeepIntShield Server **2.7.2**.
+
 `deepintshield` lets you keep writing idiomatic OpenAI / Anthropic / Bedrock /
 Google GenAI code **and** native agent-framework code (LangGraph, CrewAI,
 OpenAI Agents SDK, LlamaIndex, AutoGen, PydanticAI, Temporal, AWS Strands,
@@ -41,6 +43,9 @@ and you're done.
 
 ## Install
 
+For a reproducible installation of this release, use `pip install "deepintshield==2.7.2"`.
+Add the provider and framework extras your application needs:
+
 ```bash
 pip install deepintshield                       # core (chat, RAG, agentic)
 pip install 'deepintshield[openai]'             # + OpenAI SDK
@@ -175,17 +180,40 @@ response = openai.chat.completions.create(
 )
 ```
 
+The same client exposes the native Responses API:
+
+```python
+response = openai.responses.create(
+    model="gpt-4o-mini",
+    input="Explain this design in one sentence.",
+    store=False,
+)
+print(response.output_text)
+```
+
+Responses uses `max_output_tokens` and a `reasoning` object where supported;
+Chat Completions uses its model's supported token-limit field and
+`reasoning_effort`. For manual Responses continuations, retain the full output
+items, including tool calls and opaque reasoning state, and replay them only
+with the same provider and model. The Playground performs this mapping and
+preserves compatible response state in saved sessions.
+
 ### Anthropic
 
 ```python
 anthropic = shield.anthropic()
 response = anthropic.messages.create(
-    model="claude-3-sonnet-20240229",
+    model="claude-sonnet-5",
     max_tokens=256,
     messages=[{"role": "user", "content": "hello"}],
 )
 ```
 
+`shield.anthropic()` uses the installed Anthropic SDK's default transport class,
+including SDK releases backed by `httpx2`, and retains automatic prompt-cache
+hooks. A caller-supplied `http_client` must be compatible with that installed SDK
+and remains responsible for its own prompt-cache hooks.
+
 ### Bedrock
 
 ```python
@@ -201,11 +229,30 @@ response = bedrock.converse(
 ```python
 genai = shield.genai()
 response = genai.models.generate_content(
-    model="gemini-1.5-flash",
+    model="gemini-3.5-flash",
     contents="hello",
+    config={"automatic_function_calling": {"disable": True}},
 )
+print(response.text)
 ```
 
+Disabling automatic function calling (AFC) is optional for this text-only call.
+Recent Google SDK versions warn about direct AFC use even when no callable tools
+are supplied; that warning alone does not mean the request failed. When using
+Python callable tools, Google recommends the chat interface. Multi-turn tool
+workflows also depend on the gateway preserving tool roles and thought signatures;
+a successful text-only request does not verify those conversions.
+
+The gateway's native Gemini conversion preserves model/user tool roles, per-call
+thought signatures, and distinct IDs for parallel calls to the same function.
+SDK regression tests cover direct and chat calls, sync/async streaming, and
+callable-tool continuations. A timeout-only `http_options` override retains the
+gateway destination in SDK 2.7.2 (fixed in 2.7.1); SDK 2.7.0 does not merge that override correctly.
+
+For streaming, use `genai.models.generate_content_stream(...)` or
+`chat.send_message_stream(...)` and read each chunk's `text`. The native async
+interfaces remain available under `genai.aio`.
+
 ### LangChain
 
 ```python
@@ -277,6 +324,12 @@ retriever = shield.rag.guard_retriever(my_retriever)   # mutates in place
 docs = retriever.invoke("what is the Q2 ledger?")        # only allowed chunks
 ```
 
+Async retrievers are supported too: use `await retriever.ainvoke(query)` or
+the retriever's native async retrieval method. Filtering finishes before
+documents are returned; delegated retrieval methods filter once per call.
+Allowed documents keep their order and original framework objects. Redacted
+content is returned in copies, leaving the retriever's source documents intact.
+
 ### Guard an embedder (pre-embedding, Portkey-parity "before request")
 
 Screen input text for PII / injection / toxicity **before** it is vectorised:
@@ -715,15 +768,21 @@ OpenAI/Anthropic/LangChain conversion-loop helpers remain deprecated 2.x
 compatibility shims. Their removal is planned for SDK 3.0; new code should use
 the official session or a maintained third-party adapter.
 
+For an existing Anthropic conversion loop, use the same `shield.mcp` instance
+for `to_anthropic(tools)` and `run_anthropic_tool_uses(response.content)`.
+Provider-safe aliases distinguish qualified names that contain unsupported
+characters or exceed Anthropic's length limit; that client retains the mapping
+back to the original tool names for execution.
+
 ---
 
 ## Cost Optimization
 
-The SDK automatically participates in the gateway's two cost-reduction layers
+The SDK participates in the gateway's caching mechanisms
 (both controlled by workspace switches under **Cost Optimization**):
 
-- **Provider prompt caching** - every chat client returned by `shield.openai()`,
-  `shield.anthropic()`, etc. ships an `httpx` request hook that injects
+- **Provider prompt caching** - SDK-created OpenAI and Anthropic transports
+  include request hooks that inject
   Anthropic `cache_control` markers and an OpenAI `prompt_cache_key` so the
   provider reuses KV state for the static prompt prefix. Eligible cached tokens
   use the provider's current cached-input rate; verify model-specific pricing
@@ -737,6 +796,11 @@ The SDK automatically participates in the gateway's two cost-reduction layers
   threshold. The SDK doesn't need any code change to benefit; results flow
   back through the normal API.
 
+Cost dashboards show recorded numeric totals, using `$0.00` when no display
+value is available. Missing prices remain nullable in API log records and can
+still be found through the missing-cost filter. Estimated savings remain signed
+and are separate from the actual recorded cost.
+
 ### Per-request cache overrides
 
 Workspace settings are the default, but any individual call can override

{deepintshield-2.7.1 → deepintshield-2.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deepintshield"
-version = "2.7.1"
+version = "2.7.2"
 description = "Unified Python SDK for routing chat, RAG, agentic tool-gating, identity, and MCP traffic through DeepintShield - drop-in across the top agentic frameworks."
 readme = "README.md"
 requires-python = ">=3.10"

{deepintshield-2.7.1 → deepintshield-2.7.2}/src/deepintshield/_prompt_cache.py

@@ -25,6 +25,7 @@ from __future__ import annotations
 
 import hashlib
 import json
+from functools import lru_cache
 from typing import Any, Callable, Iterable
 
 import httpx
@@ -33,6 +34,20 @@ import httpx
 PROVIDER_ANTHROPIC = "anthropic"
 PROVIDER_OPENAI = "openai"
 
+
+@lru_cache(maxsize=8)
+def _request_byte_stream_type(request_type: type) -> type:
+    """Keep rewritten request streams in the HTTP library that owns the request."""
+    for cls in request_type.__mro__:
+        package = cls.__module__.partition(".")[0]
+        if package == "httpx2":
+            # Optional: only imported for a request from an installed httpx2 SDK.
+            from httpx2 import ByteStream
+            return ByteStream
+        if package == "httpx":
+            return httpx.ByteStream
+    return httpx.ByteStream
+
 # Anthropic accepts up to 4 cache_control markers per request. We place them in
 # priority order: system → tools → last static user/assistant block.
 _DEFAULT_BREAKPOINTS: tuple[str, ...] = ("system", "tools")
@@ -209,13 +224,7 @@ def build_request_hook(
         # the announced byte count). Reattach the stream so the new body
         # is what actually gets sent.
         request._content = encoded  # type: ignore[attr-defined]
-        try:
-            from httpx._content import ByteStream  # type: ignore
-        except ImportError:  # httpx <0.24 fallback - module path drifted.
-            from httpx import _content  # type: ignore
-            ByteStream = getattr(_content, "ByteStream", None)
-        if ByteStream is not None:
-            request.stream = ByteStream(encoded)  # type: ignore[attr-defined]
+        request.stream = _request_byte_stream_type(type(request))(encoded)
 
     return hook
 

{deepintshield-2.7.1 → deepintshield-2.7.2}/src/deepintshield/mcp/adapters/anthropic.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import re
+import hashlib
 from typing import TYPE_CHECKING, Any, Iterable, Mapping
 
 from ..tool import Tool
@@ -15,11 +16,23 @@ if TYPE_CHECKING:
 _ANTHROPIC_NAME_RE = re.compile(r"[^a-zA-Z0-9_-]")
 
 
-def to_anthropic(tools: Iterable[Tool]) -> list[dict[str, Any]]:
+def to_anthropic(
+    tools: Iterable[Tool], *, name_map: dict[str, str] | None = None,
+) -> list[dict[str, Any]]:
     """Convert ``Tool`` objects to Anthropic's Messages API tools array."""
     out: list[dict[str, Any]] = []
+    aliases = dict(name_map or {})
     for tool in tools:
-        sanitized = _ANTHROPIC_NAME_RE.sub("_", tool.qualified_name)[:64]
+        qualified = tool.qualified_name
+        sanitized = _ANTHROPIC_NAME_RE.sub("_", qualified)
+        if sanitized != qualified or len(sanitized) > 64:
+            # Truncation/replacement alone can send two different tools to
+            # the same server name. Keep a stable, provider-valid alias.
+            digest = hashlib.sha256(qualified.encode("utf-8")).hexdigest()[:16]
+            sanitized = f"{sanitized[:47]}_{digest}"
+        if sanitized in aliases and aliases[sanitized] != qualified:
+            raise ValueError("Anthropic MCP tool aliases collide")
+        aliases[sanitized] = qualified
         out.append(
             {
                 "name": sanitized,
@@ -27,6 +40,8 @@ def to_anthropic(tools: Iterable[Tool]) -> list[dict[str, Any]]:
                 "input_schema": tool.schema or {"type": "object", "properties": {}},
             }
         )
+    if name_map is not None:
+        name_map.update(aliases)
     return out
 
 
@@ -35,6 +50,7 @@ def run_tool_uses(
     content: Iterable[Any],
     *,
     extra_headers: Mapping[str, str] | None = None,
+    name_map: Mapping[str, str] | None = None,
 ) -> list[dict[str, Any]]:
     """Execute every ``tool_use`` block in an assistant content array.
 
@@ -50,7 +66,7 @@ def run_tool_uses(
             continue
         try:
             result = client.call_qualified(
-                name,
+                (name_map or {}).get(name, name),
                 args or {},
                 call_id=tool_use_id,
                 extra_headers=extra_headers,

{deepintshield-2.7.1 → deepintshield-2.7.2}/src/deepintshield/mcp/client.py

@@ -41,6 +41,7 @@ class MCPClient:
 
     def __init__(self, shield: "DeepintShield") -> None:
         self._shield = shield
+        self._anthropic_tool_names: dict[str, str] = {}
 
     # ───────────────────── preferred native MCP boundary ───────────────────
 
@@ -368,7 +369,7 @@ class MCPClient:
         """Convert tools to Anthropic Messages API ``tools=`` array shape."""
         self._warn_legacy("to_anthropic")
         from .adapters import anthropic as _anthropic
-        return _anthropic.to_anthropic(tools)
+        return _anthropic.to_anthropic(tools, name_map=self._anthropic_tool_names)
 
     def run_anthropic_tool_uses(
         self,
@@ -386,6 +387,7 @@ class MCPClient:
             self,
             content,
             extra_headers=extra_headers,
+            name_map=self._anthropic_tool_names,
         )
 
     def to_langchain(self, tools: Iterable[Tool]) -> list[Any]:

{deepintshield-2.7.1 → deepintshield-2.7.2}/src/deepintshield/providers/anthropic.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from .._prompt_cache import PROVIDER_ANTHROPIC, build_http_client
+from .._prompt_cache import PROVIDER_ANTHROPIC, build_request_hook
 from ..errors import ErrorCode, _dependency_error
 from ..transport import connection_headers, _install_agent_selector_header_hook
 
@@ -34,14 +34,28 @@ def build_client(shield: "DeepintShield", *, passthrough: bool = False, **kwargs
 
     base_url = shield.anthropic_passthrough_base_url() if passthrough else shield.anthropic_base_url()
     http_client = kwargs.pop("http_client", None)
+    owns_http_client = http_client is None
     if http_client is None:
-        http_client = build_http_client(PROVIDER_ANTHROPIC, timeout=shield.timeout)
-    _install_agent_selector_header_hook(http_client)
+        # Use the installed SDK's public transport class: older releases use
+        # httpx, while current releases require httpx2 and reject httpx.Client.
+        http_client = anthropic.DefaultHttpxClient(
+            timeout=shield.timeout,
+            follow_redirects=False,
+            event_hooks={"request": [build_request_hook(PROVIDER_ANTHROPIC)]},
+        )
 
-    return anthropic.Anthropic(
-        base_url=kwargs.pop("base_url", base_url),
-        api_key=kwargs.pop("api_key", shield.api_key()),
-        default_headers=connection_headers(shield, extra=kwargs.pop("default_headers", None)),
-        http_client=http_client,
-        **kwargs,
-    )
+    try:
+        client = anthropic.Anthropic(
+            base_url=kwargs.pop("base_url", base_url),
+            api_key=kwargs.pop("api_key", shield.api_key()),
+            default_headers=connection_headers(shield, extra=kwargs.pop("default_headers", None)),
+            http_client=http_client,
+            **kwargs,
+        )
+    except Exception:
+        if owns_http_client:
+            http_client.close()
+        raise
+    # Let the SDK validate caller-supplied transports before mutating hooks.
+    _install_agent_selector_header_hook(http_client)
+    return client

{deepintshield-2.7.1 → deepintshield-2.7.2}/src/deepintshield/rag.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+import asyncio
 import functools
+import inspect
+from contextvars import ContextVar
 from copy import deepcopy
 from dataclasses import replace
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Mapping
@@ -13,6 +16,7 @@ if TYPE_CHECKING:
 
 # Retrieve-style methods we know how to wrap, in priority order.
 _RETRIEVE_METHODS = ("invoke", "retrieve", "_get_relevant_documents", "get_relevant_documents")
+_ASYNC_RETRIEVE_METHODS = ("ainvoke", "aretrieve", "_aget_relevant_documents", "aget_relevant_documents")
 
 
 def _query_text(query: Any) -> str:
@@ -166,33 +170,31 @@ class RAGSurface:
         """Wrap a framework retriever so every retrieved chunk is filtered
         through the gateway's RAG-security evaluate before it reaches the LLM.
 
-        Works with any retriever exposing one of ``invoke`` / ``retrieve`` /
-        ``_get_relevant_documents`` (LangChain ``BaseRetriever``, LlamaIndex
+        Works with retrievers exposing ``invoke`` / ``retrieve`` /
+        ``_get_relevant_documents`` or their async counterparts (LangChain ``BaseRetriever``, LlamaIndex
         retrievers, or a custom callable object). Mutates the retriever in
         place and returns it, so existing graph/chain wiring is unchanged.
 
         Unauthorised chunks are dropped and redacted documents are copied
         with sanitized content. Source documents and allowed order are preserved.
         """
-        method_name = next(
-            (m for m in _RETRIEVE_METHODS if callable(getattr(retriever, m, None))), None
-        )
-        if method_name is None:
+        method_names = [m for m in (*_RETRIEVE_METHODS, *_ASYNC_RETRIEVE_METHODS)
+                        if callable(getattr(retriever, m, None))]
+        if not method_names:
             raise _annotate_error(
                 TypeError(
                     "guard_retriever: retriever exposes no known retrieve method "
-                    f"({', '.join(_RETRIEVE_METHODS)})"
+                    f"({', '.join((*_RETRIEVE_METHODS, *_ASYNC_RETRIEVE_METHODS))})"
                 ),
                 ErrorCode.RAG_RETRIEVER_UNSUPPORTED,
             )
-        original = getattr(retriever, method_name)
-        if getattr(original, "_deepintshield_wrapped", False):
-            return retriever
         surface = self
+        # Framework entry points often delegate to one another, including
+        # ainvoke -> a worker thread -> invoke. Filter once at the outer call;
+        # independent async tasks must retain their own evaluation context.
+        retrieving: ContextVar[bool] = ContextVar("deepintshield_retrieving", default=False)
 
-        @functools.wraps(original)
-        def wrapped(query: Any, *args: Any, **kwargs: Any) -> Any:
-            docs = original(query, *args, **kwargs)
+        def filter_result(query: Any, docs: Any) -> Any:
             if not isinstance(docs, (list, tuple)) or not docs:
                 return docs
             return surface._filter_documents(
@@ -202,11 +204,54 @@ class RAGSurface:
                 **eval_kwargs,
             )
 
-        wrapped._deepintshield_wrapped = True  # type: ignore[attr-defined]
-        try:
-            setattr(retriever, method_name, wrapped)
-        except Exception:  # frozen pydantic model
-            object.__setattr__(retriever, method_name, wrapped)
+        def wrap(original: Callable[..., Any], asynchronous: bool) -> Callable[..., Any]:
+            @functools.wraps(original)
+            async def async_wrapped(query: Any, *args: Any, **kwargs: Any) -> Any:
+                nested = retrieving.get()
+                token = retrieving.set(True)
+                try:
+                    docs = original(query, *args, **kwargs)
+                    if inspect.isawaitable(docs):
+                        docs = await docs
+                finally:
+                    retrieving.reset(token)
+                if nested:
+                    return docs
+                return await asyncio.to_thread(filter_result, query, docs)
+
+            @functools.wraps(original)
+            def sync_wrapped(query: Any, *args: Any, **kwargs: Any) -> Any:
+                if retrieving.get():
+                    return original(query, *args, **kwargs)
+                token = retrieving.set(True)
+                try:
+                    docs = original(query, *args, **kwargs)
+                finally:
+                    retrieving.reset(token)
+                if inspect.isawaitable(docs):
+                    async def complete() -> Any:
+                        token = retrieving.set(True)
+                        try:
+                            resolved = await docs
+                        finally:
+                            retrieving.reset(token)
+                        return await asyncio.to_thread(filter_result, query, resolved)
+                    return complete()
+                return filter_result(query, docs)
+
+            wrapped = async_wrapped if asynchronous else sync_wrapped
+            wrapped._deepintshield_wrapped = True  # type: ignore[attr-defined]
+            return wrapped
+
+        for method_name in method_names:
+            original = getattr(retriever, method_name)
+            if getattr(original, "_deepintshield_wrapped", False):
+                continue
+            wrapped = wrap(original, inspect.iscoroutinefunction(original) or method_name in _ASYNC_RETRIEVE_METHODS)
+            try:
+                setattr(retriever, method_name, wrapped)
+            except Exception:  # frozen pydantic model
+                object.__setattr__(retriever, method_name, wrapped)
         return retriever
 
     def _filter_documents(

{deepintshield-2.7.1 → deepintshield-2.7.2}/src/deepintshield/transport.py

@@ -14,7 +14,8 @@ consumed by :mod:`deepintshield.frameworks` and re-exported on the client as
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Mapping, Optional
+from inspect import iscoroutinefunction
+from typing import TYPE_CHECKING, Any, Mapping, Optional
 
 import httpx
 
@@ -50,8 +51,10 @@ async def _normalize_agent_selector_headers_async(request: httpx.Request) -> Non
     _normalize_agent_selector_headers(request)
 
 
-def _install_agent_selector_header_hook(client: httpx.Client | httpx.AsyncClient) -> None:
-    hook = _normalize_agent_selector_headers_async if isinstance(client, httpx.AsyncClient) else _normalize_agent_selector_headers
+def _install_agent_selector_header_hook(client: Any) -> None:
+    # Both httpx and httpx2 expose async send methods, but their AsyncClient
+    # classes are unrelated. Match the operation instead of one package type.
+    hook = _normalize_agent_selector_headers_async if iscoroutinefunction(client.send) else _normalize_agent_selector_headers
     hooks = client.event_hooks.setdefault("request", [])
     if hook not in hooks:
         hooks.append(hook)

deepintshield-2.7.2/src/deepintshield/version.py

@@ -0,0 +1 @@
+__version__ = "2.7.2"