ragaai-catalyst 2.1b4__py3-none-any.whl → 2.1.1__py3-none-any.whl

ragaai_catalyst/tracers/agentic_tracing/README.md

@@ -0,0 +1,97 @@
+# Agentic Tracing
+
+This module provides tracing functionality for agentic AI systems, helping track and analyze various aspects of AI agent behavior including LLM interactions, tool usage, and network activities.
+
+## Directory Structure
+
+```
+agentic_tracing/
+├── tracers/                  # Core tracing implementations
+│   ├── main_tracer.py       # Main tracing functionality
+│   ├── agent_tracer.py      # Agent behavior tracing
+│   ├── base.py              # Base tracing classes
+│   ├── llm_tracer.py        # Language model interaction tracing
+│   ├── network_tracer.py    # Network activity tracing
+│   ├── tool_tracer.py       # Tool usage tracing
+│   ├── user_interaction_tracer.py # User interaction tracing
+│   └── __init__.py          # Tracer module initialization
+├── data/                     # Data structures and classes
+│   ├── data_classes.py      # Data class definitions
+│   └── __init__.py          # Data module initialization
+├── utils/                    # Utility functions and helpers
+│   ├── api_utils.py         # API-related utilities
+│   ├── file_name_tracker.py # Tracks file names and paths
+│   ├── generic.py           # Generic utility functions
+│   ├── llm_utils.py         # LLM-specific utilities
+│   ├── model_costs.json     # Model cost configurations
+│   ├── trace_utils.py       # General tracing utilities
+│   ├── unique_decorator.py  # Unique ID generation
+│   ├── zip_list_of_unique_files.py # File handling utilities
+│   └── __init__.py          # Utils module initialization
+├── tests/                    # Test suites and examples
+│   ├── ai_travel_agent.py   # Travel agent test implementation
+│   ├── unique_decorator_test.py # Tests for unique decorator
+│   ├── TravelPlanner.ipynb  # Travel planner example notebook
+│   ├── FinancialAnalysisSystem.ipynb # Financial analysis example
+│   ├── GameActivityEventPlanner.ipynb # Game event planner example
+│   └── __init__.py          # Tests module initialization
+├── upload/                   # Upload functionality
+│   ├── upload_code.py       # Code upload utilities
+│   └── __init__.py          # Upload module initialization
+└── __init__.py              # Package initialization
+```
+
+## Components
+
+### Tracers
+Different types of tracers for various aspects of agent behavior:
+- Main Tracer: Core tracing functionality for managing and coordinating different trace types
+- Agent Tracer: Tracks agent behavior, decisions, and state changes
+- Base Tracer: Provides base classes and common functionality for all tracers
+- LLM Tracer: Monitors language model interactions, including:
+  - Token usage tracking
+  - Cost calculation
+  - Input/output monitoring
+  - Model parameter tracking
+- Network Tracer: Tracks network activities and API calls
+- Tool Tracer: Monitors tool usage and execution
+- User Interaction Tracer: Tracks user interactions and feedback
+
+### Data
+Core data structures and classes:
+- Data Classes: Defines structured data types for:
+  - LLM calls
+  - Network requests
+  - Tool executions
+  - Trace components
+  - Agent states
+  - User interactions
+
+### Utils
+Helper functions and utilities:
+- API Utils: Handles API-related operations and configurations
+- LLM Utils: Utilities for handling LLM-specific operations:
+  - Model name extraction
+  - Token usage calculation
+  - Cost computation
+  - Parameter sanitization
+- Generic Utils: Common utility functions used across modules
+- Trace Utils: General tracing utilities
+- File Name Tracker: Manages file paths and names
+- Unique Decorator: Generates unique identifiers for trace components
+- Model Costs: Configuration for different model pricing
+- Zip List of Unique Files: Handles file compression and unique file management
+
+### Tests
+Test suites and example implementations:
+- AI Travel Agent: Test implementation of a travel planning agent
+- Unique Decorator Tests: Unit tests for unique ID generation
+- Example Notebooks:
+  - Travel Planner: Example of travel planning implementation
+  - Financial Analysis: Example of financial system analysis
+  - Game Event Planner: Example of game activity planning
+
+### Upload
+Components for uploading and managing trace data:
+- Code Upload: Handles uploading of traced code and execution data
+- Supports various data formats and trace types

ragaai_catalyst/tracers/agentic_tracing/__init__.py

@@ -1,3 +1,5 @@
-from .agentic_tracing import AgenticTracing
+from .tracers.main_tracer import AgenticTracing
+from .utils.file_name_tracker import TrackName
+from .utils.unique_decorator import generate_unique_hash_simple, mydecorator
 
-__all__ = ['AgenticTracing']
+__all__ = ['AgenticTracing', 'TrackName', 'generate_unique_hash_simple', 'mydecorator']

ragaai_catalyst/tracers/agentic_tracing/{data_structure.py → data/data_structure.py}

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import List, Dict, Optional, Any, Union
 from datetime import datetime
 import uuid
@@ -159,6 +159,19 @@ class ToolInfo:
     version: str
     memory_used: int
 
+@dataclass
+class LLMCall:
+    name: str
+    model_name: str
+    input_prompt: str
+    output_response: str
+    tool_call: Dict
+    token_usage: Dict[str, int]
+    cost: Dict[str, float]
+    start_time: float = field(default=0)
+    end_time: float = field(default=0)
+    duration: float = field(default=0)
+
 class Component:
     def __init__(self, id: str, hash_id: str, type: str, name: str, start_time: str, end_time: str, parent_id: int, info: Dict[str, Any], data: Dict[str, Any], network_calls: Optional[List[NetworkCall]] = None, interactions: Optional[List[Union[Interaction, Dict]]] = None, error: Optional[Dict[str, Any]] = None):
         self.id = id

ragaai_catalyst/tracers/agentic_tracing/{agent_tracer.py → tracers/agent_tracer.py}

@@ -3,12 +3,10 @@ import uuid
 from datetime import datetime
 import psutil
 from typing import Optional, Any, Dict, List
-from .unique_decorator import mydecorator
-from .unique_decorator import generate_unique_hash_simple
-
+from ..utils.unique_decorator import mydecorator, generate_unique_hash_simple
 import contextvars
 import asyncio
-from .file_name_tracker import TrackName
+from ..utils.file_name_tracker import TrackName
 
 
 class AgentTracerMixin:
@@ -20,16 +18,23 @@ class AgentTracerMixin:
         self.agent_children = contextvars.ContextVar("agent_children", default=[])
         self.component_network_calls = contextvars.ContextVar("component_network_calls", default={})
         self.component_user_interaction = contextvars.ContextVar("component_user_interaction", default={})
+        self.version = contextvars.ContextVar("version", default="1.0.0")
+        self.agent_type = contextvars.ContextVar("agent_type", default="generic")
+        self.capabilities = contextvars.ContextVar("capabilities", default=[])
+        self.start_time = contextvars.ContextVar("start_time", default=None)
+        self.input_data = contextvars.ContextVar("input_data", default=None)
         self.gt = None
 
 
-    def trace_agent(self, name: str, agent_type: str = "generic", version: str = "1.0.0", capabilities: List[str] = None):
+    def trace_agent(self, name: str, agent_type: str = None, version: str = None, capabilities: List[str] = None):
         def decorator(target):
             # Check if target is a class
             is_class = isinstance(target, type)
             tracer = self  # Store reference to tracer instance
             top_level_hash_id = generate_unique_hash_simple(target)   # Generate hash based on the decorated target code
-
+            self.version.set(version)
+            self.agent_type.set(agent_type)
+            self.capabilities.set(capabilities)
             
             if is_class:
                 # Store original __init__
@@ -160,6 +165,8 @@ class AgentTracerMixin:
             return func(*args, **kwargs)
 
         start_time = datetime.now()
+        self.start_time = start_time
+        self.input_data = self._sanitize_input(args, kwargs)
         start_memory = psutil.Process().memory_info().rss
         component_id = str(uuid.uuid4())
 
@@ -206,12 +213,11 @@ class AgentTracerMixin:
                 start_time=start_time,
                 end_time=end_time,
                 memory_used=memory_used,
-                input_data=self._sanitize_input(args, kwargs),
+                input_data=self.input_data,
                 output_data=self._sanitize_output(result),
                 children=children,
                 parent_id=parent_agent_id
             )
-
             # Add ground truth to component data if present
             if ground_truth is not None:
                 agent_component["data"]["gt"] = ground_truth
@@ -253,13 +259,12 @@ class AgentTracerMixin:
                 start_time=start_time,
                 end_time=datetime.now(),
                 memory_used=0,
-                input_data=self._sanitize_input(args, kwargs),
+                input_data=self.input_data,
                 output_data=None,
                 error=error_component,
                 children=children,
                 parent_id=parent_agent_id  # Add parent ID if exists
             )
-            
             # If this is a nested agent, add it to parent's children
             if parent_agent_id:
                 parent_component = self._agent_components.get(parent_agent_id)

ragaai_catalyst/tracers/agentic_tracing/{base.py → tracers/base.py}

@@ -10,18 +10,17 @@ import uuid
 import sys
 import tempfile
 
-from .data_structure import (
+from ..data.data_structure import (
     Trace, Metadata, SystemInfo, OSInfo, EnvironmentInfo,
     Resources, CPUResource, MemoryResource, DiskResource, NetworkResource,
     ResourceInfo, MemoryInfo, DiskInfo, NetworkInfo,
     Component, 
 )
 
-from .upload_agentic_traces import UploadAgenticTraces
-from .upload_code import upload_code
-
-from .file_name_tracker import TrackName
-from .zip_list_of_unique_files import zip_list_of_unique_files
+from ..upload.upload_agentic_traces import UploadAgenticTraces
+from ..upload.upload_code import upload_code
+from ..utils.file_name_tracker import TrackName
+from ..utils.zip_list_of_unique_files import zip_list_of_unique_files
 
 class TracerJSONEncoder(json.JSONEncoder):
     def default(self, obj):

ragaai_catalyst/tracers/agentic_tracing/{llm_tracer.py → tracers/llm_tracer.py}

@@ -3,15 +3,27 @@ import asyncio
 import psutil
 import wrapt
 import functools
+import json
+import os
+import time
 from datetime import datetime
 import uuid
 import contextvars
 import traceback
 
-from .unique_decorator import generate_unique_hash_simple   
-from .utils.trace_utils import load_model_costs
-from .utils.llm_utils import extract_llm_output
-from .file_name_tracker import TrackName
+from ..utils.llm_utils import (
+    extract_model_name,
+    extract_parameters,
+    extract_token_usage,
+    extract_input_data,
+    calculate_llm_cost,
+    sanitize_api_keys,
+    sanitize_input,
+    extract_llm_output,
+)
+from ..utils.trace_utils import load_model_costs
+from ..utils.unique_decorator import generate_unique_hash_simple   
+from ..utils.file_name_tracker import TrackName
 
 
 class LLMTracerMixin:
@@ -237,148 +249,6 @@ class LLMTracerMixin:
             setattr(obj, method_name, wrapped_method)
             self.patches.append((obj, method_name, original_method))
 
-    def _extract_model_name(self, args, kwargs, result):
-        """Extract model name from kwargs or result"""
-        # First try direct model parameter
-        model = kwargs.get("model", "")
-        
-        if not model:
-            # Try to get from instance
-            instance = kwargs.get("self", None)
-            if instance:
-                # Try model_name first (Google format)
-                if hasattr(instance, "model_name"):
-                    model = instance.model_name
-                # Try model attribute
-                elif hasattr(instance, "model"):
-                    model = instance.model
-        
-        # TODO: This way isn't scalable. The necessity for normalising model names needs to be fixed. We shouldn't have to do this
-        # Normalize Google model names
-        if model and isinstance(model, str):
-            model = model.lower()
-            if "gemini-1.5-flash" in model:
-                return "gemini-1.5-flash"
-            if "gemini-1.5-pro" in model:
-                return "gemini-1.5-pro"
-            if "gemini-pro" in model:
-                return "gemini-pro"
-
-        if 'to_dict' in dir(result):
-            result = result.to_dict()
-            if 'model_version' in result:
-                model = result['model_version']
-        
-        return model or "default"
-
-    def _extract_parameters(self, kwargs):
-        """Extract all non-null parameters from kwargs"""
-        parameters = {k: v for k, v in kwargs.items() if v is not None}
-
-        # Remove contents key in parameters (Google LLM Response)
-        if 'contents' in parameters:
-            del parameters['contents']
-
-        # Remove messages key in parameters (OpenAI message)
-        if 'messages' in parameters:
-            del parameters['messages']
-
-        if 'generation_config' in parameters:
-            generation_config = parameters['generation_config']
-            # If generation_config is already a dict, use it directly
-            if isinstance(generation_config, dict):
-                config_dict = generation_config
-            else:
-                # Convert GenerationConfig to dictionary if it has a to_dict method, otherwise try to get its __dict__
-                config_dict = getattr(generation_config, 'to_dict', lambda: generation_config.__dict__)()
-            parameters.update(config_dict)
-            del parameters['generation_config']
-            
-        return parameters
-
-    def _extract_token_usage(self, result):
-        """Extract token usage from result"""
-        # Handle coroutines
-        if asyncio.iscoroutine(result):
-            # Get the current event loop
-            loop = asyncio.get_event_loop()
-            # Run the coroutine in the current event loop
-            result = loop.run_until_complete(result)
-
-
-        # Handle standard OpenAI/Anthropic format
-        if hasattr(result, "usage"):
-            usage = result.usage
-            return {
-                "prompt_tokens": getattr(usage, "prompt_tokens", 0),
-                "completion_tokens": getattr(usage, "completion_tokens", 0),
-                "total_tokens": getattr(usage, "total_tokens", 0)
-            }
-        
-        # Handle Google GenerativeAI format with usage_metadata
-        if hasattr(result, "usage_metadata"):
-            metadata = result.usage_metadata
-            return {
-                "prompt_tokens": getattr(metadata, "prompt_token_count", 0),
-                "completion_tokens": getattr(metadata, "candidates_token_count", 0),
-                "total_tokens": getattr(metadata, "total_token_count", 0)
-            }
-        
-        # Handle Vertex AI format
-        if hasattr(result, "text"):
-            # For LangChain ChatVertexAI
-            total_tokens = getattr(result, "token_count", 0)
-            if not total_tokens and hasattr(result, "_raw_response"):
-                # Try to get from raw response
-                total_tokens = getattr(result._raw_response, "token_count", 0)
-            return {
-                # TODO: This implementation is incorrect. Vertex AI does provide this breakdown    
-                "prompt_tokens": 0,  # Vertex AI doesn't provide this breakdown
-                "completion_tokens": total_tokens,
-                "total_tokens": total_tokens
-            }
-        
-        return {    # TODO: Passing 0 in case of not recorded is not correct. This needs to be fixes. Discuss before making changes to this
-            "prompt_tokens": 0,
-            "completion_tokens": 0,
-            "total_tokens": 0
-        }
-
-    def _extract_input_data(self, args, kwargs, result):
-        return {
-            'args': args,
-            'kwargs': kwargs
-        }
-
-    def _calculate_cost(self, token_usage, model_name):
-        # TODO: Passing default cost is a faulty logic & implementation and should be fixed
-        """Calculate cost based on token usage and model"""
-        if not isinstance(token_usage, dict):
-            token_usage = {
-                "prompt_tokens": 0,
-                "completion_tokens": 0,
-                "total_tokens": token_usage if isinstance(token_usage, (int, float)) else 0
-            }
-
-        # TODO: This is a temporary fix. This needs to be fixed
-
-        # Get model costs, defaulting to Vertex AI PaLM2 costs if unknown
-        model_cost = self.model_costs.get(model_name, {
-            "input_cost_per_token": 0.0,   
-            "output_cost_per_token": 0.0   
-        })
-
-        input_cost = (token_usage.get("prompt_tokens", 0)) * model_cost.get("input_cost_per_token", 0.0)
-        output_cost = (token_usage.get("completion_tokens", 0)) * model_cost.get("output_cost_per_token", 0.0)
-        total_cost = input_cost + output_cost
-
-        # TODO: Return the value as it is, no need to round
-        return {
-            "input_cost": round(input_cost, 10),
-            "output_cost": round(output_cost, 10),
-            "total_cost": round(total_cost, 10)
-        }
-
     def create_llm_component(self, component_id, hash_id, name, llm_type, version, memory_used, start_time, end_time, input_data, output_data, cost={}, usage={}, error=None, parameters={}):
         # Update total metrics
         self.total_tokens += usage.get("total_tokens", 0)
@@ -449,10 +319,11 @@ class LLMTracerMixin:
             memory_used = max(0, end_memory - start_memory)
 
             # Extract token usage and calculate cost
-            token_usage = self._extract_token_usage(result)
-            model_name = self._extract_model_name(args, kwargs, result)
-            cost = self._calculate_cost(token_usage, model_name)
-            parameters = self._extract_parameters(kwargs)
+            model_name = extract_model_name(args, kwargs, result)
+            token_usage = extract_token_usage(result)
+            cost = calculate_llm_cost(token_usage, model_name, self.model_costs)
+            parameters = extract_parameters(kwargs)
+            input_data = extract_input_data(args, kwargs, result)
 
             # End tracking network calls for this component
             self.end_component(component_id)
@@ -461,9 +332,6 @@ class LLMTracerMixin:
             if name is None:
                 name = original_func.__name__
             
-            # Create input data with ground truth
-            input_data = self._extract_input_data(args, kwargs, result)
-            
             # Create LLM component
             llm_component = self.create_llm_component(
                 component_id=component_id,
@@ -501,12 +369,6 @@ class LLMTracerMixin:
             name = self.current_llm_call_name.get()
             if name is None:
                 name = original_func.__name__
-
-            end_memory = psutil.Process().memory_info().rss
-            memory_used = max(0, end_memory - start_memory)
-            
-            # Get parent agent ID if exists
-            parent_agent_id = self.current_agent_id.get() if hasattr(self, 'current_agent_id') else None
             
             llm_component = self.create_llm_component(
                 component_id=component_id,
@@ -514,24 +376,15 @@ class LLMTracerMixin:
                 name=name,
                 llm_type="unknown",
                 version="1.0.0",
-                memory_used=memory_used,
+                memory_used=0,
                 start_time=start_time,
                 end_time=end_time,
-                input_data=self._extract_input_data(args, kwargs, None),
+                input_data=extract_input_data(args, kwargs, None),
                 output_data=None,
-                error=error_component,
-                parent_id=parent_agent_id
+                error=error_component
             )
     
-            # If this is part of an agent trace, add it to agent's children
-            if parent_agent_id and hasattr(self, 'agent_children'):
-                parent_children = self.agent_children.get()
-                parent_children.append(llm_component)
-                self.agent_children.set(parent_children)
-            else:
-                # Only add to root components if no parent
-                self.add_component(llm_component)
-                
+            self.add_component(llm_component)
             raise
 
     def trace_llm_call_sync(self, original_func, *args, **kwargs):
@@ -563,10 +416,11 @@ class LLMTracerMixin:
             memory_used = max(0, end_memory - start_memory)
 
             # Extract token usage and calculate cost
-            token_usage = self._extract_token_usage(result)
-            model_name = self._extract_model_name(args, kwargs, result)
-            cost = self._calculate_cost(token_usage, model_name)
-            parameters = self._extract_parameters(kwargs)
+            model_name = extract_model_name(args, kwargs, result)
+            token_usage = extract_token_usage(result)
+            cost = calculate_llm_cost(token_usage, model_name, self.model_costs)
+            parameters = extract_parameters(kwargs)
+            input_data = extract_input_data(args, kwargs, result)
 
             # End tracking network calls for this component
             self.end_component(component_id)
@@ -574,9 +428,6 @@ class LLMTracerMixin:
             name = self.current_llm_call_name.get()
             if name is None:
                 name = original_func.__name__
-
-            # Create input data with ground truth
-            input_data = self._extract_input_data(args, kwargs, result)
             
             # Create LLM component
             llm_component = self.create_llm_component(
@@ -594,7 +445,7 @@ class LLMTracerMixin:
                 usage=token_usage,
                 parameters=parameters
             )
-            
+            self.llm_data = llm_component
             self.add_component(llm_component)
             return result
 
@@ -618,9 +469,6 @@ class LLMTracerMixin:
             end_memory = psutil.Process().memory_info().rss
             memory_used = max(0, end_memory - start_memory)
             
-            # Get parent agent ID if exists
-            parent_agent_id = self.current_agent_id.get() if hasattr(self, 'current_agent_id') else None
-            
             llm_component = self.create_llm_component(
                 component_id=component_id,
                 hash_id=hash_id,
@@ -630,24 +478,16 @@ class LLMTracerMixin:
                 memory_used=memory_used,
                 start_time=start_time,
                 end_time=end_time,
-                input_data=self._extract_input_data(args, kwargs, None),
+                input_data=extract_input_data(args, kwargs, None),
                 output_data=None,
-                error=error_component,
-                parent_id=parent_agent_id
+                error=error_component
             )
-    
-            # If this is part of an agent trace, add it to agent's children
-            if parent_agent_id and hasattr(self, 'agent_children'):
-                parent_children = self.agent_children.get()
-                parent_children.append(llm_component)
-                self.agent_children.set(parent_children)
-            else:
-                # Only add to root components if no parent
-                self.add_component(llm_component)
-                
+            self.llm_data = llm_component
+            self.add_component(llm_component, is_error=True)
             raise
 
     def trace_llm(self, name: str = None):
+        self.current_llm_call_name.set(name)
         def decorator(func):
             @self.file_tracker.trace_decorator
             @functools.wraps(func)
@@ -661,7 +501,6 @@ class LLMTracerMixin:
                 parent_agent_id = self.current_agent_id.get()
                 self.start_component(component_id)
                 
-                start_time = datetime.now()
                 error_info = None
                 result = None
                 
@@ -681,7 +520,8 @@ class LLMTracerMixin:
                 finally:
 
                     llm_component = self.llm_data
-                    llm_component['name'] = name
+                    if (name is not None) or (name != ""):
+                        llm_component['name'] = name 
 
                     if self.gt:
                         llm_component["data"]["gt"] = self.gt
@@ -731,6 +571,8 @@ class LLMTracerMixin:
                 finally:
 
                     llm_component = self.llm_data
+                    if (name is not None) or (name != ""):
+                        llm_component['name'] = name 
 
                     if error_info:
                         llm_component["error"] = error_info["error"]
@@ -755,85 +597,3 @@ class LLMTracerMixin:
             except Exception as e:
                 print(f"Error unpatching {method_name}: {str(e)}")
         self.patches = []
-
-    def _sanitize_api_keys(self, data):
-        """Remove sensitive information from data"""
-        if isinstance(data, dict):
-            return {k: self._sanitize_api_keys(v) for k, v in data.items() 
-                    if not any(sensitive in k.lower() for sensitive in ['key', 'token', 'secret', 'password'])}
-        elif isinstance(data, list):
-            return [self._sanitize_api_keys(item) for item in data]
-        elif isinstance(data, tuple):
-            return tuple(self._sanitize_api_keys(item) for item in data)
-        return data
-
-    def _sanitize_input(self, args, kwargs):
-        """Convert input arguments to text format.
-        
-        Args:
-            args: Input arguments that may contain nested dictionaries
-            
-        Returns:
-            str: Text representation of the input arguments
-        """
-        if isinstance(args, dict):
-            return str({k: self._sanitize_input(v, {}) for k, v in args.items()})
-        elif isinstance(args, (list, tuple)):
-            return str([self._sanitize_input(item, {}) for item in args])
-        return str(args)
-
-def extract_llm_output(result):
-    """Extract output from LLM response"""
-    class OutputResponse:
-        def __init__(self, output_response):
-            self.output_response = output_response
-
-    # Handle coroutines
-    if asyncio.iscoroutine(result):
-        # For sync context, run the coroutine
-        if not asyncio.get_event_loop().is_running():
-            result = asyncio.run(result)
-        else:
-            # We're in an async context, but this function is called synchronously
-            # Return a placeholder and let the caller handle the coroutine
-            return OutputResponse("Coroutine result pending")
-
-    # Handle Google GenerativeAI format
-    if hasattr(result, "result"):
-        candidates = getattr(result.result, "candidates", [])
-        output = []
-        for candidate in candidates:
-            content = getattr(candidate, "content", None)
-            if content and hasattr(content, "parts"):
-                for part in content.parts:
-                    if hasattr(part, "text"):
-                        output.append({
-                            "content": part.text,
-                            "role": getattr(content, "role", "assistant"),
-                            "finish_reason": getattr(candidate, "finish_reason", None)
-                        })
-        return OutputResponse(output)
-    
-    # Handle Vertex AI format
-    if hasattr(result, "text"):
-        return OutputResponse([{
-            "content": result.text,
-            "role": "assistant"
-        }])
-    
-    # Handle OpenAI format
-    if hasattr(result, "choices"):
-        return OutputResponse([{
-            "content": choice.message.content,
-            "role": choice.message.role
-        } for choice in result.choices])
-    
-    # Handle Anthropic format
-    if hasattr(result, "completion"):
-        return OutputResponse([{
-            "content": result.completion,
-            "role": "assistant"
-        }])
-    
-    # Default case
-    return OutputResponse(str(result))