aiecs 1.7.6__py3-none-any.whl → 1.7.17__py3-none-any.whl

aiecs/domain/agent/models.py

@@ -381,6 +381,16 @@ class AgentMetrics(BaseModel):
     p95_operation_time: Optional[float] = Field(None, ge=0, description="95th percentile operation time in seconds")
     p99_operation_time: Optional[float] = Field(None, ge=0, description="99th percentile operation time in seconds")
 
+    # Prompt cache metrics (for LLM provider-level caching observability)
+    total_llm_requests: int = Field(default=0, ge=0, description="Total number of LLM requests made")
+    cache_hits: int = Field(default=0, ge=0, description="Number of LLM requests with cache hits")
+    cache_misses: int = Field(default=0, ge=0, description="Number of LLM requests without cache hits (cache creation)")
+    cache_hit_rate: float = Field(default=0.0, ge=0.0, le=1.0, description="Prompt cache hit rate (0-1)")
+    total_cache_read_tokens: int = Field(default=0, ge=0, description="Total tokens read from prompt cache")
+    total_cache_creation_tokens: int = Field(default=0, ge=0, description="Total tokens used to create cache entries")
+    estimated_cache_savings_tokens: int = Field(default=0, ge=0, description="Estimated tokens saved from cache (cache_read_tokens * 0.9)")
+    estimated_cache_savings_cost: float = Field(default=0.0, ge=0, description="Estimated cost saved from cache in USD")
+
     # Timestamps
     last_reset_at: Optional[datetime] = Field(None, description="When metrics were last reset")
     updated_at: datetime = Field(default_factory=datetime.utcnow, description="Last metrics update")

aiecs/domain/agent/tools/schema_generator.py

@@ -207,6 +207,12 @@ class ToolSchemaGenerator:
         if not hasattr(schema_class, "model_fields"):
             return properties, required
 
+        # Import PydanticUndefined for v2 compatibility
+        try:
+            from pydantic_core import PydanticUndefined
+        except ImportError:
+            PydanticUndefined = type(None)  # Fallback for Pydantic v1
+
         for field_name, field_info in schema_class.model_fields.items():
             # Build property schema
             prop_schema: Dict[str, Any] = {}
@@ -219,11 +225,18 @@ class ToolSchemaGenerator:
             if hasattr(field_info, "description") and field_info.description:
                 prop_schema["description"] = field_info.description
 
-            # Get default value
-            if field_info.default is not None and field_info.default != inspect.Parameter.empty:
-                prop_schema["default"] = field_info.default
+            # Check if required using Pydantic v2 API (preferred)
+            if hasattr(field_info, "is_required") and callable(field_info.is_required):
+                if field_info.is_required():
+                    required.append(field_name)
+                elif field_info.default is not None and field_info.default is not PydanticUndefined:
+                    prop_schema["default"] = field_info.default
             else:
-                required.append(field_name)
+                # Fallback for Pydantic v1
+                if field_info.default is None or field_info.default == inspect.Parameter.empty:
+                    required.append(field_name)
+                else:
+                    prop_schema["default"] = field_info.default
 
             properties[field_name] = prop_schema
 

aiecs/llm/client_factory.py

@@ -7,6 +7,7 @@ from .clients.openai_client import OpenAIClient
 from .clients.vertex_client import VertexAIClient
 from .clients.googleai_client import GoogleAIClient
 from .clients.xai_client import XAIClient
+from .clients.openai_compatible_mixin import StreamChunk
 from .callbacks.custom_callbacks import CustomAsyncCallbackHandler
 
 if TYPE_CHECKING:
@@ -407,7 +408,11 @@ class LLMClientManager:
                 max_tokens=max_tokens,
                 **kwargs,
             ):
-                collected_content += chunk
+                # Handle StreamChunk objects (when return_chunks=True or function calling)
+                if hasattr(chunk, 'content') and chunk.content:
+                    collected_content += chunk.content
+                elif isinstance(chunk, str):
+                    collected_content += chunk
                 yield chunk
 
             # Create a response object for callbacks (streaming doesn't return LLMResponse directly)

aiecs/llm/clients/base_client.py

@@ -139,7 +139,11 @@ class SafetyBlockError(LLMClientError):
         if self.block_type:
             msg += f" (Block type: {self.block_type})"
         if self.safety_ratings:
-            categories = [r.get("category", "UNKNOWN") for r in self.safety_ratings if r.get("blocked")]
+            # Safely extract categories, handling potential non-dict elements
+            categories = []
+            for r in self.safety_ratings:
+                if isinstance(r, dict) and r.get("blocked"):
+                    categories.append(r.get("category", "UNKNOWN"))
             if categories:
                 msg += f" (Categories: {', '.join(categories)})"
         return msg

aiecs/llm/clients/google_function_calling_mixin.py

@@ -5,6 +5,7 @@ Provides shared implementation for Google providers (Vertex AI, Google AI)
 that use FunctionDeclaration format for Function Calling.
 """
 
+import json
 import logging
 from typing import Dict, Any, Optional, List, Union, AsyncGenerator
 from dataclasses import dataclass
@@ -12,8 +13,6 @@ from vertexai.generative_models import (
     FunctionDeclaration,
     Tool,
 )
-from google.genai.types import Schema, Type
-
 from .base_client import LLMMessage, LLMResponse
 
 logger = logging.getLogger(__name__)
@@ -32,13 +31,46 @@ except ImportError:
         tool_calls: Optional[List[Dict[str, Any]]] = None
 
 
+def _serialize_function_args(args) -> str:
+    """
+    Safely serialize function call arguments to JSON string.
+
+    Handles MapComposite/protobuf objects from Vertex AI by converting
+    them to regular dicts before JSON serialization.
+
+    Args:
+        args: Function call arguments (may be MapComposite, dict, or other)
+
+    Returns:
+        JSON string representation of the arguments
+    """
+    if args is None:
+        return "{}"
+
+    # Handle MapComposite/protobuf objects (they have items() method)
+    if hasattr(args, 'items'):
+        # Convert to regular dict
+        args_dict = dict(args)
+    elif isinstance(args, dict):
+        args_dict = args
+    else:
+        # Try to convert to dict if possible
+        try:
+            args_dict = dict(args)
+        except (TypeError, ValueError):
+            # Last resort: use str() but this should rarely happen
+            return str(args)
+
+    return json.dumps(args_dict, ensure_ascii=False)
+
+
 class GoogleFunctionCallingMixin:
     """
     Mixin class providing Google Function Calling implementation.
-    
+
     This mixin can be used by Google providers (Vertex AI, Google AI)
     that use FunctionDeclaration format for Function Calling.
-    
+
     Usage:
         class VertexAIClient(BaseLLMClient, GoogleFunctionCallingMixin):
             async def generate_text(self, messages, tools=None, ...):
@@ -71,15 +103,13 @@ class GoogleFunctionCallingMixin:
                 if not func_name:
                     logger.warning(f"Skipping tool without name: {tool}")
                     continue
-                
-                # Convert parameters schema
-                google_schema = self._convert_json_schema_to_google_schema(func_parameters)
-                
-                # Create FunctionDeclaration
+
+                # Create FunctionDeclaration with raw dict parameters
+                # Let Vertex SDK handle the schema conversion internally
                 function_declaration = FunctionDeclaration(
                     name=func_name,
                     description=func_description,
-                    parameters=google_schema,
+                    parameters=func_parameters,
                 )
                 
                 function_declarations.append(function_declaration)
@@ -91,78 +121,6 @@ class GoogleFunctionCallingMixin:
             return [Tool(function_declarations=function_declarations)]
         return []
 
-    def _convert_json_schema_to_google_schema(
-        self, json_schema: Dict[str, Any]
-    ) -> Schema:
-        """
-        Convert JSON Schema to Google Schema format.
-        
-        Args:
-            json_schema: JSON Schema dictionary
-            
-        Returns:
-            Google Schema object
-        """
-        schema_type = json_schema.get("type", "object")
-        properties = json_schema.get("properties", {})
-        required = json_schema.get("required", [])
-        
-        # Convert type
-        google_type = self._convert_json_type_to_google_type(schema_type)
-        
-        # Convert properties (only for object types)
-        google_properties = None
-        if schema_type == "object" and properties:
-            google_properties = {}
-            for prop_name, prop_schema in properties.items():
-                google_properties[prop_name] = self._convert_json_schema_to_google_schema(
-                    prop_schema
-                )
-        
-        # Handle array items
-        items = None
-        if schema_type == "array" and "items" in json_schema:
-            items = self._convert_json_schema_to_google_schema(json_schema["items"])
-        
-        # Create Schema
-        schema_kwargs = {
-            "type": google_type,
-        }
-        
-        if google_properties is not None:
-            schema_kwargs["properties"] = google_properties
-        
-        if required:
-            schema_kwargs["required"] = required
-        
-        if items is not None:
-            schema_kwargs["items"] = items
-        
-        schema = Schema(**schema_kwargs)
-        
-        return schema
-
-    def _convert_json_type_to_google_type(self, json_type: str) -> Type:
-        """
-        Convert JSON Schema type to Google Type enum.
-        
-        Args:
-            json_type: JSON Schema type string
-            
-        Returns:
-            Google Type enum value
-        """
-        type_mapping = {
-            "string": Type.STRING,
-            "number": Type.NUMBER,
-            "integer": Type.NUMBER,  # Google uses NUMBER for both
-            "boolean": Type.BOOLEAN,
-            "array": Type.ARRAY,
-            "object": Type.OBJECT,
-        }
-        
-        return type_mapping.get(json_type.lower(), Type.OBJECT)
-
     def _extract_function_calls_from_google_response(
         self, response: Any
     ) -> Optional[List[Dict[str, Any]]]:
@@ -191,10 +149,10 @@ class GoogleFunctionCallingMixin:
                     "type": "function",
                     "function": {
                         "name": func_call.name,
-                        "arguments": str(func_call.args) if hasattr(func_call, "args") else "{}",
+                        "arguments": _serialize_function_args(func_call.args) if hasattr(func_call, "args") else "{}",
                     },
                 })
-            
+
             # Check for content.parts with function_call (newer API)
             elif hasattr(candidate, "content") and hasattr(candidate.content, "parts"):
                 for part in candidate.content.parts:
@@ -205,7 +163,7 @@ class GoogleFunctionCallingMixin:
                             "type": "function",
                             "function": {
                                 "name": func_call.name,
-                                "arguments": str(func_call.args) if hasattr(func_call, "args") else "{}",
+                                "arguments": _serialize_function_args(func_call.args) if hasattr(func_call, "args") else "{}",
                             },
                         })
         
@@ -300,10 +258,10 @@ class GoogleFunctionCallingMixin:
                             "type": "function",
                             "function": {
                                 "name": func_call.name,
-                                "arguments": str(func_call.args) if hasattr(func_call, "args") else "{}",
+                                "arguments": _serialize_function_args(func_call.args) if hasattr(func_call, "args") else "{}",
                             },
                         })
-            
+
             # Check for function_call attribute directly on candidate
             elif hasattr(candidate, "function_call") and candidate.function_call:
                 func_call = candidate.function_call
@@ -312,7 +270,7 @@ class GoogleFunctionCallingMixin:
                     "type": "function",
                     "function": {
                         "name": func_call.name,
-                        "arguments": str(func_call.args) if hasattr(func_call, "args") else "{}",
+                        "arguments": _serialize_function_args(func_call.args) if hasattr(func_call, "args") else "{}",
                     },
                 })
         

aiecs/llm/clients/googleai_client.py

@@ -1,3 +1,4 @@
+import json
 import logging
 import os
 from typing import Optional, List, AsyncGenerator
@@ -45,14 +46,86 @@ class GoogleAIClient(BaseLLMClient):
     def _convert_messages_to_contents(
         self, messages: List[LLMMessage]
     ) -> List[types.Content]:
-        """Convert LLMMessage list to Google GenAI Content objects."""
+        """
+        Convert LLMMessage list to Google GenAI Content objects.
+
+        This properly handles multi-turn conversations including
+        function/tool responses for Google AI Function Calling.
+
+        Args:
+            messages: List of LLMMessage objects (system messages should be filtered out)
+
+        Returns:
+            List of Content objects for Google AI API
+        """
         contents = []
+
         for msg in messages:
-            # Map 'assistant' role to 'model' for Google AI
-            role = "model" if msg.role == "assistant" else msg.role
-            contents.append(
-                types.Content(role=role, parts=[types.Part(text=msg.content)])
-            )
+            # Handle tool/function responses (role="tool")
+            if msg.role == "tool":
+                # Google AI expects function responses as user messages with FunctionResponse parts
+                func_name = msg.tool_call_id or "unknown_function"
+
+                # Parse content as the function response
+                try:
+                    if msg.content and msg.content.strip().startswith('{'):
+                        response_data = json.loads(msg.content)
+                    else:
+                        response_data = {"result": msg.content}
+                except json.JSONDecodeError:
+                    response_data = {"result": msg.content}
+
+                # Create FunctionResponse part
+                func_response_part = types.Part.from_function_response(
+                    name=func_name,
+                    response=response_data
+                )
+
+                contents.append(types.Content(
+                    role="user",  # Function responses are sent as "user" role
+                    parts=[func_response_part]
+                ))
+
+            # Handle assistant messages with tool calls
+            elif msg.role == "assistant" and msg.tool_calls:
+                parts = []
+                if msg.content:
+                    parts.append(types.Part(text=msg.content))
+
+                for tool_call in msg.tool_calls:
+                    func = tool_call.get("function", {})
+                    func_name = func.get("name", "")
+                    func_args = func.get("arguments", "{}")
+
+                    # Parse arguments
+                    try:
+                        args_dict = json.loads(func_args) if isinstance(func_args, str) else func_args
+                    except json.JSONDecodeError:
+                        args_dict = {}
+
+                    # Create FunctionCall part using types.FunctionCall
+                    # Note: types.Part.from_function_call() may not exist in google.genai
+                    # Use FunctionCall type directly
+                    function_call = types.FunctionCall(
+                        name=func_name,
+                        args=args_dict
+                    )
+                    parts.append(types.Part(function_call=function_call))
+
+                contents.append(types.Content(
+                    role="model",
+                    parts=parts
+                ))
+
+            # Handle regular messages (user, assistant without tool_calls)
+            else:
+                role = "model" if msg.role == "assistant" else msg.role
+                if msg.content:
+                    contents.append(types.Content(
+                        role=role,
+                        parts=[types.Part(text=msg.content)]
+                    ))
+
         return contents
 
     async def generate_text(