payi 0.1.0a83__tar.gz → 0.1.0a85__tar.gz

payi-0.1.0a85/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.1.0-alpha.85"
+}

{payi-0.1.0a83 → payi-0.1.0a85}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.1.0-alpha.85 (2025-06-12)
+
+Full Changelog: [v0.1.0-alpha.84...v0.1.0-alpha.85](https://github.com/Pay-i/pay-i-python/compare/v0.1.0-alpha.84...v0.1.0-alpha.85)
+
+### Features
+
+* AnthropicBedrock ([#320](https://github.com/Pay-i/pay-i-python/issues/320)) ([33b42e3](https://github.com/Pay-i/pay-i-python/commit/33b42e38d7ba3245e0633254b4401cf991937933))
+
+## 0.1.0-alpha.84 (2025-06-09)
+
+Full Changelog: [v0.1.0-alpha.83...v0.1.0-alpha.84](https://github.com/Pay-i/pay-i-python/compare/v0.1.0-alpha.83...v0.1.0-alpha.84)
+
+### Features
+
+* **api:** manual updates ([b5edce3](https://github.com/Pay-i/pay-i-python/commit/b5edce3207c9cd01ded791e67b8cc0bbf5ef4ef4))
+* consolidate anthropic vision, google.genai and vertex compute usage ([#318](https://github.com/Pay-i/pay-i-python/issues/318)) ([28700fd](https://github.com/Pay-i/pay-i-python/commit/28700fd25e76b03e06f9cb7c963890dbb1675f2b))
+
 ## 0.1.0-alpha.83 (2025-06-06)
 
 Full Changelog: [v0.1.0-alpha.82...v0.1.0-alpha.83](https://github.com/Pay-i/pay-i-python/compare/v0.1.0-alpha.82...v0.1.0-alpha.83)

{payi-0.1.0a83 → payi-0.1.0a85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: payi
-Version: 0.1.0a83
+Version: 0.1.0a85
 Summary: The official Python library for the payi API
 Project-URL: Homepage, https://github.com/Pay-i/pay-i-python
 Project-URL: Repository, https://github.com/Pay-i/pay-i-python

{payi-0.1.0a83 → payi-0.1.0a85}/api.md

@@ -108,6 +108,12 @@ Methods:
 - <code title="get /api/v1/categories/{category}/resources/{resource}">client.categories.resources.<a href="./src/payi/resources/categories/resources.py">list</a>(resource, \*, category, \*\*<a href="src/payi/types/categories/resource_list_params.py">params</a>) -> <a href="./src/payi/types/category_resource_response.py">SyncCursorPage[CategoryResourceResponse]</a></code>
 - <code title="delete /api/v1/categories/{category}/resources/{resource}/{resource_id}">client.categories.resources.<a href="./src/payi/resources/categories/resources.py">delete</a>(resource_id, \*, category, resource) -> <a href="./src/payi/types/category_resource_response.py">CategoryResourceResponse</a></code>
 
+## FixedCostResources
+
+Methods:
+
+- <code title="post /api/v1/categories/{category}/fixed_cost_resources/{resource}">client.categories.fixed_cost_resources.<a href="./src/payi/resources/categories/fixed_cost_resources.py">create</a>(resource, \*, category, \*\*<a href="src/payi/types/categories/fixed_cost_resource_create_params.py">params</a>) -> <a href="./src/payi/types/category_resource_response.py">CategoryResourceResponse</a></code>
+
 # Experiences
 
 Types:

{payi-0.1.0a83 → payi-0.1.0a85}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "payi"
-version = "0.1.0-alpha.83"
+version = "0.1.0-alpha.85"
 description = "The official Python library for the payi API"
 dynamic = ["readme"]
 license = "Apache-2.0"

{payi-0.1.0a83 → payi-0.1.0a85}/src/payi/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "payi"
-__version__ = "0.1.0-alpha.83"  # x-release-please-version
+__version__ = "0.1.0-alpha.85"  # x-release-please-version

{payi-0.1.0a83 → payi-0.1.0a85}/src/payi/lib/AnthropicInstrumentor.py

@@ -1,3 +1,4 @@
+import json
 from typing import Any, Union, Optional, Sequence
 from typing_extensions import override
 
@@ -17,6 +18,12 @@ class AnthropicInstrumentor:
 
         return isinstance(instance._client, (AsyncAnthropicVertex, AnthropicVertex))
 
+    @staticmethod
+    def is_bedrock(instance: Any) -> bool:
+        from anthropic import AnthropicBedrock, AsyncAnthropicBedrock  # type: ignore # noqa: I001
+
+        return isinstance(instance._client, (AsyncAnthropicBedrock, AnthropicBedrock))
+
     @staticmethod
     def instrument(instrumentor: _PayiInstrumentor) -> None:
         try:
@@ -125,94 +132,46 @@ async def astream_messages_wrapper(
 
 class _AnthropicProviderRequest(_ProviderRequest):
     def __init__(self, instrumentor: _PayiInstrumentor, streaming_type: _StreamingType, instance: Any = None) -> None:
-        self._vertex: bool = AnthropicInstrumentor.is_vertex(instance)
+        self._is_vertex: bool = AnthropicInstrumentor.is_vertex(instance)
+        self._is_bedrock: bool = AnthropicInstrumentor.is_bedrock(instance)
+    
+        category: str = ""
+        if self._is_vertex:
+            category = PayiCategories.google_vertex
+        elif self._is_bedrock:
+            category = PayiCategories.aws_bedrock
+        else:
+            category = PayiCategories.anthropic
+
+        instrumentor._logger.debug(f"Anthropic messages instrumenting category {category}")
+
         super().__init__(
             instrumentor=instrumentor,
-            category=PayiCategories.google_vertex if self._vertex else PayiCategories.anthropic,
+            category=category,
             streaming_type=streaming_type,
             )
 
     @override
     def process_chunk(self, chunk: Any) -> _ChunkResult:
-        ingest = False
-        if chunk.type == "message_start":
-            self._ingest["provider_response_id"] = chunk.message.id
-
-            usage = chunk.message.usage
-            units = self._ingest["units"]
-
-            input = _PayiInstrumentor.update_for_vision(usage.input_tokens, units, self._estimated_prompt_tokens)
-
-            units["text"] = Units(input=input, output=0)
-
-            if hasattr(usage, "cache_creation_input_tokens") and usage.cache_creation_input_tokens > 0:
-                text_cache_write = usage.cache_creation_input_tokens
-                units["text_cache_write"] = Units(input=text_cache_write, output=0)
-
-            if hasattr(usage, "cache_read_input_tokens") and usage.cache_read_input_tokens > 0:
-                text_cache_read = usage.cache_read_input_tokens
-                units["text_cache_read"] = Units(input=text_cache_read, output=0)
-
-        elif chunk.type == "message_delta":
-            usage = chunk.usage
-            ingest = True
-
-            # Web search will return an updated input tokens value at the end of streaming
-            if usage.input_tokens > 0:
-                self._ingest["units"]["text"]["input"] = usage.input_tokens
-
-            self._ingest["units"]["text"]["output"] = usage.output_tokens
-        
-        return _ChunkResult(send_chunk_to_caller=True, ingest=ingest)
+        return anthropic_process_chunk(self, chunk.to_dict(), assign_id=True)
 
     @override
     def process_synchronous_response(self, response: Any, log_prompt_and_response: bool, kwargs: Any) -> Any:
-        usage = response.usage
-        input = usage.input_tokens
-        output = usage.output_tokens
-        units: dict[str, Units] = self._ingest["units"]
-
-        if hasattr(usage, "cache_creation_input_tokens") and usage.cache_creation_input_tokens > 0:
-            text_cache_write = usage.cache_creation_input_tokens
-            units["text_cache_write"] = Units(input=text_cache_write, output=0)
-
-        if hasattr(usage, "cache_read_input_tokens") and usage.cache_read_input_tokens > 0:
-            text_cache_read = usage.cache_read_input_tokens
-            units["text_cache_read"] = Units(input=text_cache_read, output=0)
+        anthropic_process_synchronous_response(
+            request=self,
+            response=response.to_dict(),
+            log_prompt_and_response=log_prompt_and_response,
+            assign_id=True)
 
-        input = _PayiInstrumentor.update_for_vision(input, units, self._estimated_prompt_tokens)
-
-        units["text"] = Units(input=input, output=output)
-
-        if log_prompt_and_response:
-            self._ingest["provider_response_json"] = response.to_json()
-        
-        self._ingest["provider_response_id"] = response.id
-        
         return None
 
     @override
     def process_request(self, instance: Any, extra_headers: 'dict[str, str]', args: Sequence[Any], kwargs: Any) -> bool:
-        self._ingest["resource"] = ("anthropic." if self._vertex else "") + kwargs.get("model", "")
+        self._ingest["resource"] = ("anthropic." if self._is_vertex else "") + kwargs.get("model", "")
 
         messages = kwargs.get("messages")
         if messages:
-            estimated_token_count = 0 
-            has_image = False
-
-            try:
-                enc = tiktoken.get_encoding("cl100k_base")
-                for message in messages:
-                    msg_has_image, msg_prompt_tokens = has_image_and_get_texts(enc, message.get('content', ''))
-                    if msg_has_image:
-                        has_image = True
-                        estimated_token_count += msg_prompt_tokens
-                
-                if has_image and estimated_token_count > 0:
-                    self._estimated_prompt_tokens = estimated_token_count
-     
-            except Exception:
-                self._instrumentor._logger.warning("Error getting encoding for cl100k_base")
+            anthropic_has_image_and_get_texts(self, messages)
 
         return True
 
@@ -248,6 +207,88 @@ class _AnthropicProviderRequest(_ProviderRequest):
 
         return True
 
+def anthropic_process_synchronous_response(request: _ProviderRequest, response: 'dict[str, Any]', log_prompt_and_response: bool, assign_id: bool) -> Any:
+    usage = response['usage']
+    input = usage['input_tokens']
+    output = usage['output_tokens']
+    units: dict[str, Units] = request._ingest["units"]
+
+    cache_creation_input_tokens = usage.get("cache_creation_input_tokens", 0)
+    if cache_creation_input_tokens > 0:
+        units["text_cache_write"] = Units(input=cache_creation_input_tokens, output=0)
+
+    cache_read_input_tokens = usage.get("cache_read_input_tokens", 0)
+    if cache_read_input_tokens > 0:
+        units["text_cache_read"] = Units(input=cache_read_input_tokens, output=0)
+
+    input = _PayiInstrumentor.update_for_vision(input, units, request._estimated_prompt_tokens)
+
+    units["text"] = Units(input=input, output=output)
+
+    if log_prompt_and_response:
+        request._ingest["provider_response_json"] = json.dumps(response)
+    
+    if assign_id:
+        request._ingest["provider_response_id"] = response.get('id', None)
+    
+    return None
+
+def anthropic_process_chunk(request: _ProviderRequest, chunk: 'dict[str, Any]', assign_id: bool) -> _ChunkResult:    
+    ingest = False
+    type = chunk.get('type', "")
+
+    if type == "message_start":
+        message = chunk['message']
+
+        if assign_id:
+            request._ingest["provider_response_id"] = message.get('id', None)
+
+        usage = message['usage']
+        units = request._ingest["units"]
+
+        input = _PayiInstrumentor.update_for_vision(usage['input_tokens'], units, request._estimated_prompt_tokens)
+
+        units["text"] = Units(input=input, output=0)
+
+        text_cache_write: int = usage.get("cache_creation_input_tokens", 0)
+        if text_cache_write > 0:
+            units["text_cache_write"] = Units(input=text_cache_write, output=0)
+
+        text_cache_read: int = usage.get("cache_read_input_tokens", 0)
+        if text_cache_read > 0:
+            units["text_cache_read"] = Units(input=text_cache_read, output=0)
+
+    elif type == "message_delta":
+        usage = chunk.get('usage', {})
+        ingest = True
+
+        # Web search will return an updated input tokens value at the end of streaming
+        input_tokens = usage.get('input_tokens', None)
+        if input_tokens is not None:
+            request._ingest["units"]["text"]["input"] = input_tokens
+
+        request._ingest["units"]["text"]["output"] = usage.get('output_tokens', 0)
+    
+    return _ChunkResult(send_chunk_to_caller=True, ingest=ingest)
+
+
+def anthropic_has_image_and_get_texts(request: _ProviderRequest, messages: Any) -> None:
+    estimated_token_count = 0 
+    has_image = False
+
+    try:
+        enc = tiktoken.get_encoding("cl100k_base")
+        for message in messages:
+            msg_has_image, msg_prompt_tokens = has_image_and_get_texts(enc, message.get('content', ''))
+            if msg_has_image:
+                has_image = True
+                estimated_token_count += msg_prompt_tokens
+        
+        if has_image and estimated_token_count > 0:
+            request._estimated_prompt_tokens = estimated_token_count
+
+    except Exception:
+        request._instrumentor._logger.warning("Error getting encoding for cl100k_base")
 
 def has_image_and_get_texts(encoding: tiktoken.Encoding, content: Union[str, 'list[Any]']) -> 'tuple[bool, int]':
     if isinstance(content, list): # type: ignore

{payi-0.1.0a83 → payi-0.1.0a85}/src/payi/lib/BedrockInstrumentor.py

@@ -7,12 +7,11 @@ from typing_extensions import override
 from wrapt import ObjectProxy, wrap_function_wrapper  # type: ignore
 
 from payi.lib.helpers import PayiCategories, PayiHeaderNames, payi_aws_bedrock_url
-from payi.types.ingest_units_params import Units, IngestUnitsParams
+from payi.types.ingest_units_params import Units
 from payi.types.pay_i_common_models_api_router_header_info_param import PayICommonModelsAPIRouterHeaderInfoParam
 
 from .instrument import _ChunkResult, _IsStreaming, _StreamingType, _ProviderRequest, _PayiInstrumentor
 
-_supported_model_prefixes = ["meta.llama3", "anthropic.", "amazon.nova-pro", "amazon.nova-lite", "amazon.nova-micro"]
 
 class BedrockInstrumentor:
     _instrumentor: _PayiInstrumentor
@@ -100,15 +99,13 @@ class InvokeResponseWrapper(ObjectProxy): # type: ignore
     def __init__(
         self,
         response: Any,
-        instrumentor: _PayiInstrumentor,
-        ingest: IngestUnitsParams,
+        request: '_BedrockInvokeProviderRequest',
         log_prompt_and_response: bool
         ) -> None:
 
         super().__init__(response) # type: ignore
         self._response = response
-        self._instrumentor = instrumentor
-        self._ingest = ingest
+        self._request = request
         self._log_prompt_and_response = log_prompt_and_response
 
     def read(self, amt: Any =None) -> Any: # type: ignore
@@ -116,51 +113,50 @@ class InvokeResponseWrapper(ObjectProxy): # type: ignore
         data: bytes = self.__wrapped__.read(amt) # type: ignore
         response = json.loads(data) # type: ignore
 
-        resource = self._ingest["resource"]
+        ingest = self._request._ingest
+
+        resource = ingest["resource"]
         if not resource:
             return
         
         input: int = 0
         output: int = 0
-        units: dict[str, Units] = self._ingest["units"]
+        units: dict[str, Units] = ingest["units"]
+
+        if self._request._is_anthropic:
+            from .AnthropicInstrumentor import anthropic_process_synchronous_response
 
-        if resource.startswith("meta.llama3"):
+            anthropic_process_synchronous_response(
+                request=self._request, 
+                response=response,
+                log_prompt_and_response=False, # will evaluate logging later
+                assign_id=False)
+
+        elif resource.startswith("meta.llama3"):
             input = response['prompt_token_count']
             output = response['generation_token_count']
-        elif resource.startswith("anthropic."):
-            usage = response['usage']
-            input = usage['input_tokens']
-            output = usage['output_tokens']
-        units["text"] = Units(input=input, output=output)
+            units["text"] = Units(input=input, output=output)
 
         if self._log_prompt_and_response:
-            self._ingest["provider_response_json"] = data.decode('utf-8') # type: ignore
+            ingest["provider_response_json"] = data.decode('utf-8') # type: ignore
             
-        self._instrumentor._ingest_units(self._ingest)
+        self._request._instrumentor._ingest_units(ingest)
 
         return data # type: ignore
 
-def _is_supported_model(modelId: str) -> bool:
-    return any(prefix in modelId for prefix in _supported_model_prefixes)
-
 def wrap_invoke(instrumentor: _PayiInstrumentor, wrapped: Any) -> Any:
     @wraps(wrapped)
     def invoke_wrapper(*args: Any, **kwargs: 'dict[str, Any]') -> Any:
         modelId:str = kwargs.get("modelId", "") # type: ignore
 
-        if _is_supported_model(modelId):
-            instrumentor._logger.debug(f"bedrock invoke wrapper, modelId: {modelId}")
-            return instrumentor.invoke_wrapper(
-                _BedrockInvokeSynchronousProviderRequest(instrumentor=instrumentor),
-                _IsStreaming.false,
-                wrapped,
-                None,
-                args,
-                kwargs,
-            )   
-
-        instrumentor._logger.debug(f"bedrock invoke wrapper, unsupported modelId: {modelId}")
-        return wrapped(*args, **kwargs)
+        return instrumentor.invoke_wrapper(
+            _BedrockInvokeProviderRequest(instrumentor=instrumentor, model_id=modelId),
+            _IsStreaming.false,
+            wrapped,
+            None,
+            args,
+            kwargs,
+        )   
     
     return invoke_wrapper
 
@@ -169,18 +165,15 @@ def wrap_invoke_stream(instrumentor: _PayiInstrumentor, wrapped: Any) -> Any:
     def invoke_wrapper(*args: Any, **kwargs: Any) -> Any:
         modelId: str = kwargs.get("modelId", "") # type: ignore
 
-        if _is_supported_model(modelId):
-            instrumentor._logger.debug(f"bedrock invoke stream wrapper, modelId: {modelId}")
-            return instrumentor.invoke_wrapper(
-                _BedrockInvokeStreamingProviderRequest(instrumentor=instrumentor, model_id=modelId),
-                _IsStreaming.true,
-                wrapped,
-                None,
-                args,
-                kwargs,
-            )
-        instrumentor._logger.debug(f"bedrock invoke stream wrapper, unsupported modelId: {modelId}")
-        return wrapped(*args, **kwargs)
+        instrumentor._logger.debug(f"bedrock invoke stream wrapper, modelId: {modelId}")
+        return instrumentor.invoke_wrapper(
+            _BedrockInvokeProviderRequest(instrumentor=instrumentor, model_id=modelId),
+            _IsStreaming.true,
+            wrapped,
+            None,
+            args,
+            kwargs,
+        )
 
     return invoke_wrapper
 
@@ -189,18 +182,15 @@ def wrap_converse(instrumentor: _PayiInstrumentor, wrapped: Any) -> Any:
     def invoke_wrapper(*args: Any, **kwargs: 'dict[str, Any]') -> Any:
         modelId:str = kwargs.get("modelId", "") # type: ignore
 
-        if _is_supported_model(modelId):
-            instrumentor._logger.debug(f"bedrock converse wrapper, modelId: {modelId}")
-            return instrumentor.invoke_wrapper(
-                _BedrockConverseSynchronousProviderRequest(instrumentor=instrumentor),
-                _IsStreaming.false,
-                wrapped,
-                None,
-                args,
-                kwargs,
+        instrumentor._logger.debug(f"bedrock converse wrapper, modelId: {modelId}")
+        return instrumentor.invoke_wrapper(
+            _BedrockConverseProviderRequest(instrumentor=instrumentor),
+            _IsStreaming.false,
+            wrapped,
+            None,
+            args,
+            kwargs,
         )
-        instrumentor._logger.debug(f"bedrock converse wrapper, unsupported modelId: {modelId}")
-        return wrapped(*args, **kwargs)
     
     return invoke_wrapper
 
@@ -209,18 +199,15 @@ def wrap_converse_stream(instrumentor: _PayiInstrumentor, wrapped: Any) -> Any:
     def invoke_wrapper(*args: Any, **kwargs: Any) -> Any:
         modelId: str = kwargs.get("modelId", "") # type: ignore
 
-        if _is_supported_model(modelId):
-            instrumentor._logger.debug(f"bedrock converse stream wrapper, modelId: {modelId}")
-            return instrumentor.invoke_wrapper(
-                _BedrockConverseStreamingProviderRequest(instrumentor=instrumentor),
-                _IsStreaming.true,
-                wrapped,
-                None,
-                args,
-                kwargs,
-            )
-        instrumentor._logger.debug(f"bedrock converse stream wrapper, unsupported modelId: {modelId}")
-        return wrapped(*args, **kwargs)
+        instrumentor._logger.debug(f"bedrock converse stream wrapper, modelId: {modelId}")
+        return instrumentor.invoke_wrapper(
+            _BedrockConverseProviderRequest(instrumentor=instrumentor),
+            _IsStreaming.true,
+            wrapped,
+            None,
+            args,
+            kwargs,
+        )
 
     return invoke_wrapper
 
@@ -230,6 +217,7 @@ class _BedrockProviderRequest(_ProviderRequest):
             instrumentor=instrumentor,
             category=PayiCategories.aws_bedrock,
             streaming_type=_StreamingType.iterator,
+            is_aws_client=True,
             )
 
     @override
@@ -239,6 +227,10 @@ class _BedrockProviderRequest(_ProviderRequest):
         self._ingest["resource"] = kwargs.get("modelId", "")
         return True
 
+    @override
+    def process_initial_stream_response(self, response: Any) -> None:
+        self._ingest["provider_response_id"] = response.get("ResponseMetadata", {}).get("RequestId", None)
+
     @override
     def process_exception(self, exception: Exception, kwargs: Any, ) -> bool:
         try:
@@ -264,10 +256,27 @@ class _BedrockProviderRequest(_ProviderRequest):
             self._instrumentor._logger.debug(f"Error processing exception: {e}")
             return False
 
-class _BedrockInvokeStreamingProviderRequest(_BedrockProviderRequest):
+class _BedrockInvokeProviderRequest(_BedrockProviderRequest):
     def __init__(self, instrumentor: _PayiInstrumentor, model_id: str):
         super().__init__(instrumentor=instrumentor)
-        self._is_anthropic: bool = model_id.startswith("anthropic.")
+        self._is_anthropic: bool = 'anthropic' in model_id
+
+    @override
+    def process_request(self, instance: Any, extra_headers: 'dict[str, str]', args: Sequence[Any], kwargs: Any) -> bool:
+        from .AnthropicInstrumentor import anthropic_has_image_and_get_texts
+
+        super().process_request(instance, extra_headers, args, kwargs)
+    
+        if self._is_anthropic:
+            try:
+                body = json.loads( kwargs.get("body", ""))
+                messages = body.get("messages", {})
+                if messages:
+                    anthropic_has_image_and_get_texts(self, messages)
+            except Exception as e:
+                self._instrumentor._logger.debug(f"Bedrock invoke error processing request body: {e}")
+
+        return True
 
     @override
     def process_chunk(self, chunk: Any) -> _ChunkResult:
@@ -277,32 +286,9 @@ class _BedrockInvokeStreamingProviderRequest(_BedrockProviderRequest):
             return self.process_invoke_streaming_llama_chunk(chunk)
 
     def process_invoke_streaming_anthropic_chunk(self, chunk: str) -> _ChunkResult:
-        ingest = False
-        chunk_dict =  json.loads(chunk)
-        type = chunk_dict.get("type", "")
-
-        if type == "message_start":
-            usage = chunk_dict['message']['usage']
-            units = self._ingest["units"]
-
-            input = _PayiInstrumentor.update_for_vision(usage['input_tokens'], units, self._estimated_prompt_tokens)
-
-            units["text"] = Units(input=input, output=0)
-
-            text_cache_write: int = usage.get("cache_creation_input_tokens", 0)
-            if text_cache_write > 0:
-                units["text_cache_write"] = Units(input=text_cache_write, output=0)
-
-            text_cache_read: int = usage.get("cache_read_input_tokens", 0)
-            if text_cache_read > 0:
-                units["text_cache_read"] = Units(input=text_cache_read, output=0)
-
-        elif type == "message_delta":
-            usage = chunk_dict['usage']
-            self._ingest["units"]["text"]["output"] = usage['output_tokens']
-            ingest = True
-
-        return _ChunkResult(send_chunk_to_caller=True, ingest=ingest)    
+        from .AnthropicInstrumentor import anthropic_process_chunk
+        
+        return anthropic_process_chunk(self, json.loads(chunk), assign_id=False)
 
     def process_invoke_streaming_llama_chunk(self, chunk: str) -> _ChunkResult:
         ingest = False
@@ -316,7 +302,6 @@ class _BedrockInvokeStreamingProviderRequest(_BedrockProviderRequest):
 
         return _ChunkResult(send_chunk_to_caller=True, ingest=ingest)    
 
-class _BedrockInvokeSynchronousProviderRequest(_BedrockProviderRequest):
     @override
     def process_synchronous_response(
         self,
@@ -336,13 +321,12 @@ class _BedrockInvokeSynchronousProviderRequest(_BedrockProviderRequest):
 
         response["body"] = InvokeResponseWrapper(
             response=response["body"],
-            instrumentor=self._instrumentor,
-            ingest=self._ingest,
+            request=self,
             log_prompt_and_response=log_prompt_and_response)
 
         return response
 
-class _BedrockConverseSynchronousProviderRequest(_BedrockProviderRequest):
+class _BedrockConverseProviderRequest(_BedrockProviderRequest):
     @override
     def process_synchronous_response(
         self,
@@ -374,7 +358,6 @@ class _BedrockConverseSynchronousProviderRequest(_BedrockProviderRequest):
 
         return None    
 
-class _BedrockConverseStreamingProviderRequest(_BedrockProviderRequest):
     @override
     def process_chunk(self, chunk: 'dict[str, Any]') -> _ChunkResult:
         ingest = False