payi 0.1.0a85__tar.gz → 0.1.0a87__tar.gz

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

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

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

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.1.0-alpha.87 (2025-06-16)
+
+Full Changelog: [v0.1.0-alpha.86...v0.1.0-alpha.87](https://github.com/Pay-i/pay-i-python/compare/v0.1.0-alpha.86...v0.1.0-alpha.87)
+
+### Features
+
+* capture function calling ([#324](https://github.com/Pay-i/pay-i-python/issues/324)) ([5e89cb8](https://github.com/Pay-i/pay-i-python/commit/5e89cb8f8526cd8c9053683e40a9d6c9a1773742))
+
+## 0.1.0-alpha.86 (2025-06-13)
+
+Full Changelog: [v0.1.0-alpha.85...v0.1.0-alpha.86](https://github.com/Pay-i/pay-i-python/compare/v0.1.0-alpha.85...v0.1.0-alpha.86)
+
+### Bug Fixes
+
+* anthopic logging ([#322](https://github.com/Pay-i/pay-i-python/issues/322)) ([1af515b](https://github.com/Pay-i/pay-i-python/commit/1af515b9603058cf23b75e477fbb67e7acd405ad))
+
 ## 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)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: payi
-Version: 0.1.0a85
+Version: 0.1.0a87
 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.0a85 → payi-0.1.0a87}/pyproject.toml

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

{payi-0.1.0a85 → payi-0.1.0a87}/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.85"  # x-release-please-version
+__version__ = "0.1.0-alpha.87"  # x-release-please-version

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

@@ -169,6 +169,8 @@ class _AnthropicProviderRequest(_ProviderRequest):
     def process_request(self, instance: Any, extra_headers: 'dict[str, str]', args: Sequence[Any], kwargs: Any) -> bool:
         self._ingest["resource"] = ("anthropic." if self._is_vertex else "") + kwargs.get("model", "")
 
+        self._instrumentor._logger.debug(f"Processing anthropic request: model {self._ingest['resource']}, category {self._category}")
+
         messages = kwargs.get("messages")
         if messages:
             anthropic_has_image_and_get_texts(self, messages)
@@ -225,6 +227,20 @@ def anthropic_process_synchronous_response(request: _ProviderRequest, response:
 
     units["text"] = Units(input=input, output=output)
 
+    content = response.get('content', [])
+    if content:
+        for c in content:
+            if c.get("type", "") != "tool_use":
+                continue
+            name = c.get("name", "")
+            input = c.get("input", "")
+            arguments: Optional[str] = None
+            if input and isinstance(input, dict):
+                arguments = json.dumps(input, ensure_ascii=False)
+            
+            if name and arguments:
+                request.add_synchronous_function_call(name=name, arguments=arguments)
+
     if log_prompt_and_response:
         request._ingest["provider_response_json"] = json.dumps(response)
     
@@ -243,6 +259,11 @@ def anthropic_process_chunk(request: _ProviderRequest, chunk: 'dict[str, Any]',
         if assign_id:
             request._ingest["provider_response_id"] = message.get('id', None)
 
+        model = message.get('model', None)
+        if model:
+            request._instrumentor._logger.debug(f"Anthropic streaming, reported model: {model}, instrumented model {request._ingest['resource']}")
+
+
         usage = message['usage']
         units = request._ingest["units"]
 
@@ -258,6 +279,8 @@ def anthropic_process_chunk(request: _ProviderRequest, chunk: 'dict[str, Any]',
         if text_cache_read > 0:
             units["text_cache_read"] = Units(input=text_cache_read, output=0)
 
+        request._instrumentor._logger.debug(f"Anthropic streaming captured {input} input tokens, ")
+
     elif type == "message_delta":
         usage = chunk.get('usage', {})
         ingest = True
@@ -265,12 +288,42 @@ def anthropic_process_chunk(request: _ProviderRequest, chunk: 'dict[str, Any]',
         # 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._instrumentor._logger.debug(f"Anthropic streaming finished, updated input tokens: {input_tokens}")
             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)
 
+        request._instrumentor._logger.debug(f"Anthropic streaming finished: output tokens {usage.get('output_tokens', 0)} ")
+
+    elif type == "content_block_start":
+        request._building_function_response = False
+
+        content_block = chunk.get('content_block', {})
+        if content_block and content_block.get('type', "") == "tool_use":
+            index = chunk.get('index', None)
+            name = content_block.get('name', "")
+
+            if index and isinstance(index, int) and name:
+                request._building_function_response = True
+                request.add_streaming_function_call(index=index, name=name, arguments=None)
+
+    elif type == "content_block_delta":
+        if request._building_function_response:
+            delta = chunk.get("delta", {})
+            type = delta.get("type", "")
+            partial_json = delta.get("partial_json", "")
+            index = chunk.get('index', None)
+
+            if index and isinstance(index, int) and type == "input_json_delta" and partial_json:
+                request.add_streaming_function_call(index=index, name=None, arguments=partial_json)
+
+    elif type == "content_block_stop":
+        request._building_function_response = False
+
+    else:
+        request._instrumentor._logger.debug(f"Anthropic streaming chunk: {type}")
+        
+    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 
@@ -288,7 +341,7 @@ def anthropic_has_image_and_get_texts(request: _ProviderRequest, messages: Any)
             request._estimated_prompt_tokens = estimated_token_count
 
     except Exception:
-        request._instrumentor._logger.warning("Error getting encoding for cl100k_base")
+        request._instrumentor._logger.info("Anthropic skipping vision token calc, could not load 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.0a85 → payi-0.1.0a87}/src/payi/lib/BedrockInstrumentor.py

@@ -1,6 +1,6 @@
 import os
 import json
-from typing import Any, Sequence
+from typing import Any, Optional, Sequence
 from functools import wraps
 from typing_extensions import override
 
@@ -132,15 +132,32 @@ class InvokeResponseWrapper(ObjectProxy): # type: ignore
                 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 self._request._is_meta:
+            input = response.get('prompt_token_count', 0)
+            output = response.get('generation_token_count', 0)
             units["text"] = Units(input=input, output=output)
 
+        elif self._request._is_nova:
+            usage = response.get("usage", {})
+
+            input = usage.get("inputTokens", 0)
+            output = usage.get("outputTokens", 0)
+            units["text"] = Units(input=input, output=output)
+
+            text_cache_read = usage.get("cacheReadInputTokenCount", None)
+            if text_cache_read:
+                units["text_cache_read"] = text_cache_read
+
+            text_cache_write = usage.get("cacheWriteInputTokenCount", None)
+            if text_cache_write:
+                units["text_cache_write"] = text_cache_write
+
+            bedrock_converse_process_synchronous_function_call(self._request, response)
+
         if self._log_prompt_and_response:
             ingest["provider_response_json"] = data.decode('utf-8') # type: ignore
             
-        self._request._instrumentor._ingest_units(ingest)
+        self._request._instrumentor._ingest_units(self._request)
 
         return data # type: ignore
 
@@ -260,6 +277,8 @@ class _BedrockInvokeProviderRequest(_BedrockProviderRequest):
     def __init__(self, instrumentor: _PayiInstrumentor, model_id: str):
         super().__init__(instrumentor=instrumentor)
         self._is_anthropic: bool = 'anthropic' in model_id
+        self._is_nova: bool = 'nova' in model_id
+        self._is_meta: bool = 'meta' in model_id
 
     @override
     def process_request(self, instance: Any, extra_headers: 'dict[str, str]', args: Sequence[Any], kwargs: Any) -> bool:
@@ -280,24 +299,35 @@ class _BedrockInvokeProviderRequest(_BedrockProviderRequest):
 
     @override
     def process_chunk(self, chunk: Any) -> _ChunkResult:
-        if self._is_anthropic:
-            return self.process_invoke_streaming_anthropic_chunk(chunk)
-        else:
-            return self.process_invoke_streaming_llama_chunk(chunk)
+        chunk_dict = json.loads(chunk)
 
-    def process_invoke_streaming_anthropic_chunk(self, chunk: str) -> _ChunkResult:
-        from .AnthropicInstrumentor import anthropic_process_chunk
+        if self._is_anthropic:
+            from .AnthropicInstrumentor import anthropic_process_chunk
+            return anthropic_process_chunk(self, chunk_dict, assign_id=False)
         
-        return anthropic_process_chunk(self, json.loads(chunk), assign_id=False)
+        if self._is_nova:
+            bedrock_converse_process_streaming_for_function_call(self, chunk_dict)
+
+        # meta and nova
+        return self.process_invoke_other_provider_chunk(chunk_dict)
 
-    def process_invoke_streaming_llama_chunk(self, chunk: str) -> _ChunkResult:
+    def process_invoke_other_provider_chunk(self, chunk_dict: 'dict[str, Any]') -> _ChunkResult:
         ingest = False
-        chunk_dict =  json.loads(chunk)
+
         metrics = chunk_dict.get("amazon-bedrock-invocationMetrics", {})
         if metrics:
             input = metrics.get("inputTokenCount", 0)
             output = metrics.get("outputTokenCount", 0)
             self._ingest["units"]["text"] = Units(input=input, output=output)
+
+            text_cache_read = metrics.get("cacheReadInputTokenCount", None)
+            if text_cache_read:
+                self._ingest["units"]["text_cache_read"] = text_cache_read
+
+            text_cache_write = metrics.get("cacheWriteInputTokenCount", None)
+            if text_cache_write:
+                self._ingest["units"]["text_cache_write"] = text_cache_write
+
             ingest = True
 
         return _ChunkResult(send_chunk_to_caller=True, ingest=ingest)    
@@ -356,7 +386,9 @@ class _BedrockConverseProviderRequest(_BedrockProviderRequest):
             response_without_metadata.pop("ResponseMetadata", None)
             self._ingest["provider_response_json"] = json.dumps(response_without_metadata)
 
-        return None    
+        bedrock_converse_process_synchronous_function_call(self, response)
+
+        return None
 
     @override
     def process_chunk(self, chunk: 'dict[str, Any]') -> _ChunkResult:
@@ -371,4 +403,46 @@ class _BedrockConverseProviderRequest(_BedrockProviderRequest):
 
             ingest = True
 
-        return _ChunkResult(send_chunk_to_caller=True, ingest=ingest)
+        bedrock_converse_process_streaming_for_function_call(self, chunk)
+
+        return _ChunkResult(send_chunk_to_caller=True, ingest=ingest)
+
+def bedrock_converse_process_streaming_for_function_call(request: _ProviderRequest, chunk: 'dict[str, Any]') -> None:  
+    contentBlockStart = chunk.get("contentBlockStart", {})
+    tool_use = contentBlockStart.get("start", {}).get("toolUse", {})
+    if tool_use:
+        index = contentBlockStart.get("contentBlockIndex", None)
+        name = tool_use.get("name", "")
+
+        if name and index is not None:
+            request.add_streaming_function_call(index=index, name=name, arguments=None)
+        
+        return
+
+    contentBlockDelta = chunk.get("contentBlockDelta", {})
+    tool_use = contentBlockDelta.get("delta", {}).get("toolUse", {})
+    if tool_use:
+        index = contentBlockDelta.get("contentBlockIndex", None)
+        input = tool_use.get("input", "")
+
+        if input and index is not None:
+            request.add_streaming_function_call(index=index, name=None, arguments=input)
+
+        return
+
+def bedrock_converse_process_synchronous_function_call(request: _ProviderRequest, response: 'dict[str, Any]') -> None:
+    content = response.get("output", {}).get("message", {}).get("content", [])
+    if content:
+        for item in content:
+            tool_use = item.get("toolUse", {})
+            if tool_use:
+                name = tool_use.get("name", "")
+                input = tool_use.get("input", {})
+                arguments: Optional[str] = None
+
+                if input and isinstance(input, dict):
+                    arguments = json.dumps(input)
+                
+                if name:
+                    request.add_synchronous_function_call(name=name, arguments=arguments)
+

{payi-0.1.0a85 → payi-0.1.0a87}/src/payi/lib/GoogleGenAiInstrumentor.py

@@ -1,12 +1,10 @@
-import json
-from typing import Any, List, Union, Optional, Sequence
+from typing import Any, List, Union, Sequence
 from typing_extensions import override
 
 from wrapt import wrap_function_wrapper  # type: ignore
 
-from payi.lib.helpers import PayiCategories
-
-from .instrument import _ChunkResult, _IsStreaming, _StreamingType, _ProviderRequest, _PayiInstrumentor
+from .instrument import _ChunkResult, _IsStreaming, _PayiInstrumentor
+from .VertexRequest import _VertexRequest
 
 
 class GoogleGenAiInstrumentor:
@@ -113,13 +111,10 @@ async def agenerate_stream_wrapper(
         kwargs,
     )
 
-class _GoogleGenAiRequest(_ProviderRequest):
+class _GoogleGenAiRequest(_VertexRequest):
     def __init__(self, instrumentor: _PayiInstrumentor):
         super().__init__(
             instrumentor=instrumentor,
-            category=PayiCategories.google_vertex,
-            streaming_type=_StreamingType.generator,
-            is_google_vertex_or_genai_client=True,
             )
         self._prompt_character_count = 0
         self._candidates_character_count = 0
@@ -154,8 +149,6 @@ class _GoogleGenAiRequest(_ProviderRequest):
         if isinstance(value, list):
             items = value # type: ignore
 
-        from .VertexInstrumentor import count_chars_skip_spaces
-
         for item in items: # type: ignore
             text = ""
             if isinstance(item, Part):
@@ -166,8 +159,8 @@ class _GoogleGenAiRequest(_ProviderRequest):
                 text = item
 
             if text != "":
-                self._prompt_character_count += count_chars_skip_spaces(text) # type: ignore
-             
+                self._prompt_character_count += self.count_chars_skip_spaces(text) # type: ignore
+
         return True
 
     @override
@@ -247,65 +240,21 @@ class _GoogleGenAiRequest(_ProviderRequest):
 
     @override
     def process_chunk(self, chunk: Any) -> _ChunkResult:
-        from .VertexInstrumentor import vertex_compute_usage, count_chars_skip_spaces
-
-        ingest = False
         response_dict: dict[str, Any] = chunk.to_json_dict()
-        if "provider_response_id" not in self._ingest:
-            id = response_dict.get("response_id", None)
-            if id:
-                self._ingest["provider_response_id"] = id
 
         model: str = response_dict.get("model_version", "")
-
         self._ingest["resource"] = "google." + model
 
+        return self.process_chunk_dict(response_dict=response_dict)
 
-        for candidate in response_dict.get("candidates", []):
-            parts = candidate.get("content", {}).get("parts", [])
-            for part in parts:
-                self._candidates_character_count += count_chars_skip_spaces(part.get("text", ""))
-
-        usage = response_dict.get("usage_metadata", {})
-        if usage and "prompt_token_count" in usage and "candidates_token_count" in usage:
-            vertex_compute_usage(
-                request=self,
-                model=model,
-                response_dict=response_dict,
-                prompt_character_count=self._prompt_character_count,
-                streaming_candidates_characters=self._candidates_character_count
-                )
-            ingest = True
-
-        return _ChunkResult(send_chunk_to_caller=True, ingest=ingest)
-    
     @override
     def process_synchronous_response(
         self,
         response: Any,
         log_prompt_and_response: bool,
         kwargs: Any) -> Any:
-        response_dict = response.to_json_dict()
-
-        from .VertexInstrumentor import vertex_compute_usage
-
-        id: Optional[str] = response_dict.get("response_id", None)
-        if id:
-            self._ingest["provider_response_id"] = id
-        
-        model: Optional[str] = response_dict.get("model_version", None)
-        if model:
-            self._ingest["resource"] = "google." + model
-
-        vertex_compute_usage(
-            request=self,
-            model=model,
-            response_dict=response_dict,
-            prompt_character_count=self._prompt_character_count,
-            streaming_candidates_characters=self._candidates_character_count
-            )
-
-        if log_prompt_and_response:
-            self._ingest["provider_response_json"] = [json.dumps(response_dict)]
 
-        return None
+        return self.vertex_process_synchronous_response(
+            response_dict=response.to_json_dict(),
+            log_prompt_and_response=log_prompt_and_response,
+        )

{payi-0.1.0a85 → payi-0.1.0a87}/src/payi/lib/OpenAIInstrumentor.py

@@ -349,6 +349,19 @@ class _OpenAiChatProviderRequest(_OpenAiProviderRequest):
 
         send_chunk_to_client = True
 
+        choices = model.get("choices", [])
+        if choices:
+            for choice in choices:
+                function = choice.get("delta", {}).get("function_call", {})
+                index = choice.get("index", None)
+
+                if function and index is not None:
+                    name = function.get("name", None)
+                    arguments = function.get("arguments", None)
+
+                    if name or arguments:
+                        self.add_streaming_function_call(index=index, name=name, arguments=arguments)
+
         usage = model.get("usage")
         if usage:
             self.add_usage_units(usage)
@@ -379,7 +392,7 @@ class _OpenAiChatProviderRequest(_OpenAiProviderRequest):
                 try:
                     enc = tiktoken.get_encoding("o200k_base") # type: ignore
                 except Exception:
-                    self._instrumentor._logger.warning("Error getting encoding for fallback o200k_base")
+                    self._instrumentor._logger.info("OpenAI skipping vision token calc, could not load o200k_base")
                     enc = None
             
             if enc:
@@ -411,6 +424,22 @@ class _OpenAiChatProviderRequest(_OpenAiProviderRequest):
         response: Any,
         log_prompt_and_response: bool,
         kwargs: Any) -> Any:
+
+        response_dict = model_to_dict(response)
+        choices = response_dict.get("choices", [])
+        if choices:
+            for choice in choices:
+                function = choice.get("message", {}).get("function_call", {})
+
+                if not function:
+                    continue
+
+                name = function.get("name", None)
+                arguments = function.get("arguments", None)
+
+                if name:
+                    self.add_synchronous_function_call(name=name, arguments=arguments)
+
         return self.process_synchronous_response_worker(response, log_prompt_and_response)
 
 class _OpenAiResponsesProviderRequest(_OpenAiProviderRequest):
@@ -432,6 +461,16 @@ class _OpenAiResponsesProviderRequest(_OpenAiProviderRequest):
             if response_id:
                 self._ingest["provider_response_id"] = response_id
 
+        type = model.get("type", "")
+        if type and type == "response.output_item.done":
+            item = model.get("item", {})
+            if item and item.get("type", "") == "function_call":
+                name = item.get("name", None)
+                arguments = item.get("arguments", None)
+
+                if name:
+                    self.add_synchronous_function_call(name=name, arguments=arguments)
+
         usage = response.get("usage")
         if usage:
             self.add_usage_units(usage)
@@ -459,7 +498,7 @@ class _OpenAiResponsesProviderRequest(_OpenAiProviderRequest):
             try:
                 enc = tiktoken.get_encoding("o200k_base") # type: ignore
             except Exception:
-                self._instrumentor._logger.warning("Error getting encoding for fallback o200k_base")
+                self._instrumentor._logger.info("OpenAI skipping vision token calc, could not load o200k_base")
                 enc = None
         
         # find each content..type="input_text" and count tokens
@@ -498,6 +537,21 @@ class _OpenAiResponsesProviderRequest(_OpenAiProviderRequest):
         response: Any,
         log_prompt_and_response: bool,
         kwargs: Any) -> Any:
+
+        response_dict = model_to_dict(response)
+        output = response_dict.get("output", [])
+        if output:
+            for o in output:
+                type = o.get("type", "")
+                if type != "function_call":
+                    continue
+
+                name = o.get("name", None)
+                arguments = o.get("arguments", None)
+
+                if name:
+                    self.add_synchronous_function_call(name=name, arguments=arguments)
+
         return self.process_synchronous_response_worker(response, log_prompt_and_response)
 
 def model_to_dict(model: Any) -> Any: