ragaai-catalyst 2.1.5b0__py3-none-any.whl → 2.1.5b1__py3-none-any.whl

ragaai_catalyst/dataset.py

@@ -1,4 +1,5 @@
 import os
+import json
 import requests
 from .utils import response_checker
 from typing import Union
@@ -271,3 +272,332 @@ class Dataset:
         except Exception as e:
             logger.error(f"Error in create_from_csv: {e}")
             raise
+
+    def add_rows(self, csv_path, dataset_name):
+        """
+        Add rows to an existing dataset from a CSV file.
+
+        Args:
+            csv_path (str): Path to the CSV file to be added
+            dataset_name (str): Name of the existing dataset to add rows to
+
+        Raises:
+            ValueError: If dataset does not exist or columns are incompatible
+        """
+        # Get existing dataset columns
+        existing_columns = self.get_dataset_columns(dataset_name)
+
+        # Read the CSV file to check columns
+        try:
+            import pandas as pd
+            df = pd.read_csv(csv_path)
+            csv_columns = df.columns.tolist()
+        except Exception as e:
+            logger.error(f"Failed to read CSV file: {e}")
+            raise ValueError(f"Unable to read CSV file: {e}")
+
+        # Check column compatibility
+        for column in existing_columns:
+            if column not in csv_columns:
+                df[column] = None  
+
+        # Get presigned URL for the CSV
+        def get_presignedUrl():
+            headers = {
+                "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
+                "X-Project-Id": str(self.project_id),
+            }
+            try:
+                response = requests.get(
+                    f"{Dataset.BASE_URL}/v2/llm/dataset/csv/presigned-url",
+                    headers=headers,
+                    timeout=Dataset.TIMEOUT,
+                )
+                response.raise_for_status()
+                return response.json()
+            except requests.exceptions.RequestException as e:
+                logger.error(f"Failed to get presigned URL: {e}")
+                raise
+
+        try:
+            presignedUrl = get_presignedUrl()
+            if presignedUrl['success']:
+                url = presignedUrl['data']['presignedUrl']
+                filename = presignedUrl['data']['fileName']
+            else:
+                raise ValueError('Unable to fetch presignedUrl')
+        except Exception as e:
+            logger.error(f"Error in get_presignedUrl: {e}")
+            raise
+
+        # Upload CSV to presigned URL
+        def put_csv_to_presignedUrl(url):
+            headers = {
+                'Content-Type': 'text/csv',
+                'x-ms-blob-type': 'BlockBlob',
+            }
+            try:
+                with open(csv_path, 'rb') as file:
+                    response = requests.put(
+                        url,
+                        headers=headers,
+                        data=file,
+                        timeout=Dataset.TIMEOUT,
+                    )
+                    response.raise_for_status()
+                    return response
+            except requests.exceptions.RequestException as e:
+                logger.error(f"Failed to put CSV to presigned URL: {e}")
+                raise
+
+        try:
+            put_csv_response = put_csv_to_presignedUrl(url)
+            if put_csv_response.status_code not in (200, 201):
+                raise ValueError('Unable to put csv to the presignedUrl')
+        except Exception as e:
+            logger.error(f"Error in put_csv_to_presignedUrl: {e}")
+            raise
+
+        # Prepare schema mapping (assuming same mapping as original dataset)
+        def generate_schema_mapping(dataset_name):
+            headers = {
+                'Content-Type': 'application/json',
+                "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
+                "X-Project-Id": str(self.project_id),
+            }
+            json_data = {
+                "size": 12, 
+                "page": "0", 
+                "projectId": str(self.project_id), 
+                "search": ""
+            }
+            try:
+                # First get dataset details
+                response = requests.post(
+                    f"{Dataset.BASE_URL}/v2/llm/dataset",
+                    headers=headers,
+                    json=json_data,
+                    timeout=Dataset.TIMEOUT,
+                )
+                response.raise_for_status()
+                datasets = response.json()["data"]["content"]
+                dataset_id = [dataset["id"] for dataset in datasets if dataset["name"]==dataset_name][0]
+
+                # Get dataset details to extract schema mapping
+                response = requests.get(
+                    f"{Dataset.BASE_URL}/v2/llm/dataset/{dataset_id}?initialCols=0",
+                    headers=headers,
+                    timeout=Dataset.TIMEOUT,
+                )
+                response.raise_for_status()
+                
+                # Extract schema mapping
+                schema_mapping = {}
+                for col in response.json()["data"]["datasetColumnsResponses"]:
+                    schema_mapping[col["displayName"]] = {"columnType": col["columnType"]}
+                
+                return schema_mapping
+            except requests.exceptions.RequestException as e:
+                logger.error(f"Failed to get schema mapping: {e}")
+                raise
+
+        # Upload CSV to elastic
+        try:
+            schema_mapping = generate_schema_mapping(dataset_name)
+            
+            data = {
+                "projectId": str(self.project_id),
+                "datasetName": dataset_name,
+                "fileName": filename,
+                "schemaMapping": schema_mapping,
+                "opType": "update",  # Use update for adding rows
+                "description": "Adding new rows to dataset"
+            }
+            
+            headers = {
+                'Content-Type': 'application/json',
+                'Authorization': f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
+                "X-Project-Id": str(self.project_id)
+            }
+            
+            response = requests.post(
+                f"{Dataset.BASE_URL}/v2/llm/dataset/csv",
+                headers=headers,
+                json=data,
+                timeout=Dataset.TIMEOUT,
+            )
+            
+            if response.status_code == 400:
+                raise ValueError(response.json().get("message", "Failed to add rows"))
+            
+            response.raise_for_status()
+            
+            # Check response
+            response_data = response.json()
+            if not response_data.get('success', False):
+                raise ValueError(response_data.get('message', 'Unknown error occurred'))
+            
+            print(f"Successfully added rows to dataset {dataset_name}")
+            return response_data
+        
+        except Exception as e:
+            logger.error(f"Error in add_rows_to_dataset: {e}")
+            raise
+
+    def add_columns(self,text_fields,dataset_name, column_name, provider, model,variables={}):
+        """
+        Add a column to a dataset with dynamically fetched model parameters
+        
+        Args:
+            project_id (int): Project ID
+            dataset_id (int): Dataset ID
+            column_name (str): Name of the new column
+            provider (str): Name of the model provider
+            model (str): Name of the model
+        """
+        # First, get model parameters
+
+        # Validate text_fields input
+        if not isinstance(text_fields, list):
+            raise ValueError("text_fields must be a list of dictionaries")
+        
+        for field in text_fields:
+            if not isinstance(field, dict) or 'role' not in field or 'content' not in field:
+                raise ValueError("Each text field must be a dictionary with 'role' and 'content' keys")
+            
+        # First, get the dataset ID
+        headers = {
+            'Content-Type': 'application/json',
+            "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
+            "X-Project-Id": str(self.project_id),
+        }
+        json_data = {"size": 12, "page": "0", "projectId": str(self.project_id), "search": ""}
+        
+        try:
+            # Get dataset list
+            response = requests.post(
+                f"{Dataset.BASE_URL}/v2/llm/dataset",
+                headers=headers,
+                json=json_data,
+                timeout=Dataset.TIMEOUT,
+            )
+            response.raise_for_status()
+            datasets = response.json()["data"]["content"]
+            
+            # Find dataset ID
+            dataset_id = next((dataset["id"] for dataset in datasets if dataset["name"] == dataset_name), None)
+            
+            if dataset_id is None:
+                raise ValueError(f"Dataset {dataset_name} not found")
+
+
+
+            parameters_url= f"{Dataset.BASE_URL}/playground/providers/models/parameters/list"
+            
+            headers = {
+                'Content-Type': 'application/json',
+                "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
+                "X-Project-Id": str(self.project_id),
+            }
+            
+            # Fetch model parameters
+            parameters_payload = {
+                "providerName": provider,
+                "modelName": model
+            }
+        
+            # Get model parameters
+            params_response = requests.post(
+                parameters_url, 
+                headers=headers, 
+                json=parameters_payload, 
+                timeout=30
+            )
+            params_response.raise_for_status()
+            
+            # Extract parameters
+            all_parameters = params_response.json().get('data', [])
+            
+            # Filter and transform parameters for add-column API
+            formatted_parameters = []
+            for param in all_parameters:
+                value = param.get('value')
+                param_type = param.get('type')
+
+                if value is None:
+                    formatted_param = {
+                        "name": param.get('name'),
+                        "value": None,  # Pass None if the value is null
+                        "type": param.get('type')
+                    }
+                else:
+                    # Improved type handling
+                    if param_type == "float":
+                        value = float(value)  # Ensure value is converted to float
+                    elif param_type == "int":
+                        value = int(value)  # Ensure value is converted to int
+                    elif param_type == "bool":
+                        value = bool(value)  # Ensure value is converted to bool
+                    elif param_type == "string":
+                        value = str(value)  # Ensure value is converted to string
+                    else:
+                        raise ValueError(f"Unsupported parameter type: {param_type}")  # Handle unsupported types
+
+                    formatted_param = {
+                        "name": param.get('name'),
+                        "value": value,
+                        "type": param.get('type')
+                    }
+                formatted_parameters.append(formatted_param)
+            dataset_id = next((dataset["id"] for dataset in datasets if dataset["name"] == dataset_name), None)
+
+            # Prepare payload for add column API
+            add_column_payload = {
+                "rowFilterList": [],
+                "columnName": column_name,
+                "datasetId": dataset_id,
+                "variables": variables,
+                "promptTemplate": {
+                    "textFields": text_fields,
+                    "modelSpecs": {
+                        "model": f"{provider}/{model}",
+                        "parameters": formatted_parameters
+                    }
+                }
+            }
+            if variables:
+                variable_specs = []
+                for key, values in variables.items():
+                    variable_specs.append({
+                        "name": key,
+                        "type": "string",
+                        "schema": values
+                    })
+                add_column_payload["promptTemplate"]["variableSpecs"] = variable_specs
+            
+            # Make API call to add column
+            add_column_url = f"{Dataset.BASE_URL}/v2/llm/dataset/add-column"
+            
+            response = requests.post(
+                add_column_url, 
+                headers={
+                    'Content-Type': 'application/json',
+                    'Authorization': f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
+                    "X-Project-Id": str(self.project_id)
+                }, 
+                json=add_column_payload,
+                timeout=30
+            )
+            
+            # Check response
+            response.raise_for_status()
+            response_data = response.json()
+            
+            print("Column added successfully:")
+            print(json.dumps(response_data, indent=2))
+            return response_data
+        
+        except requests.exceptions.RequestException as e:
+            print(f"Error adding column: {e}")
+            raise
+

ragaai_catalyst/tracers/agentic_tracing/tracers/agent_tracer.py

@@ -44,6 +44,7 @@ class AgentTracerMixin:
         # Add auto instrument flags
         self.auto_instrument_agent = False
         self.auto_instrument_user_interaction = False
+        self.auto_instrument_file_io = False
         self.auto_instrument_network = False
 
     def trace_agent(
@@ -512,10 +513,22 @@ class AgentTracerMixin:
             network_calls = self.component_network_calls.get(kwargs["component_id"], [])
         interactions = []
         if self.auto_instrument_user_interaction:
-            interactions = self.component_user_interaction.get(
-                kwargs["component_id"], []
-            )
-        start_time = kwargs["start_time"]
+            input_output_interactions = []
+            for interaction in self.component_user_interaction.get(kwargs["component_id"], []):
+                if interaction["interaction_type"] in ["input", "output"]:
+                    input_output_interactions.append(interaction)
+            interactions.extend(input_output_interactions) 
+        if self.auto_instrument_file_io:
+            file_io_interactions = []
+            for interaction in self.component_user_interaction.get(kwargs["component_id"], []):
+                if interaction["interaction_type"] in ["file_read", "file_write"]:
+                    file_io_interactions.append(interaction)
+            interactions.extend(file_io_interactions)
+
+        # Get start time
+        start_time = None
+        if "start_time" in kwargs:
+            start_time = kwargs["start_time"]
 
         # Get tags, metrics
         name = kwargs["name"]
@@ -621,3 +634,6 @@ class AgentTracerMixin:
 
     def instrument_network_calls(self):
         self.auto_instrument_network = True
+        
+    def instrument_file_io_calls(self):
+        self.auto_instrument_file_io = True

ragaai_catalyst/tracers/agentic_tracing/tracers/base.py

@@ -695,11 +695,12 @@ class BaseTracer:
         # Process additional interactions and network calls
         if "interactions" in child:
             for interaction in child["interactions"]:
-                interaction["id"] = str(interaction_id)
-                interaction["span_id"] = child.get("id")
-                interaction["error"] = None
-                interactions.append(interaction)
-                interaction_id += 1
+                if interaction!=[]:
+                    interaction["id"] = str(interaction_id)
+                    interaction["span_id"] = child.get("id")
+                    interaction["error"] = None
+                    interactions.append(interaction)
+                    interaction_id += 1
 
         if "network_calls" in child:
             for child_network_call in child["network_calls"]:
@@ -876,15 +877,16 @@ class BaseTracer:
             # Process interactions from span.data if they exist
             if span.interactions:
                 for span_interaction in span.interactions:
-                    interaction = {}
-                    interaction["id"] = str(interaction_id)
-                    interaction["span_id"] = span.id
-                    interaction["interaction_type"] = span_interaction.type
-                    interaction["content"] = span_interaction.content
-                    interaction["timestamp"] = span_interaction.timestamp
-                    interaction["error"] = span.error
-                    interactions.append(interaction)
-                    interaction_id += 1
+                    if span_interaction != []:
+                        interaction = {}
+                        interaction["id"] = str(interaction_id)
+                        interaction["span_id"] = span.id
+                        interaction["interaction_type"] = span_interaction.type
+                        interaction["content"] = span_interaction.content
+                        interaction["timestamp"] = span_interaction.timestamp
+                        interaction["error"] = span.error
+                        interactions.append(interaction)
+                        interaction_id += 1
 
             if span.network_calls:
                 for span_network_call in span.network_calls:

ragaai_catalyst/tracers/agentic_tracing/tracers/custom_tracer.py

@@ -25,6 +25,7 @@ class CustomTracerMixin:
         self.auto_instrument_custom = False
         self.auto_instrument_user_interaction = False
         self.auto_instrument_network = False
+        self.auto_instrument_file_io = False
 
     def trace_custom(self, name: str = None, custom_type: str = "generic", version: str = "1.0.0", trace_variables: bool = True):
         def decorator(func):
@@ -246,8 +247,18 @@ class CustomTracerMixin:
             
         interactions = []
         if self.auto_instrument_user_interaction:
-            interactions = self.component_user_interaction.get(kwargs["component_id"], [])
-
+            input_output_interactions = []
+            for interaction in self.component_user_interaction.get(kwargs["component_id"], []):
+                if interaction["interaction_type"] in ["input", "output"]:
+                    input_output_interactions.append(interaction)
+            interactions.extend(input_output_interactions) 
+        if self.auto_instrument_file_io:
+            file_io_interactions = []
+            for interaction in self.component_user_interaction.get(kwargs["component_id"], []):
+                if interaction["interaction_type"] in ["file_read", "file_write"]:
+                    file_io_interactions.append(interaction)
+            interactions.extend(file_io_interactions)
+            
         component = {
             "id": kwargs["component_id"],
             "hash_id": kwargs["hash_id"],
@@ -314,3 +325,7 @@ class CustomTracerMixin:
     def instrument_network_calls(self):
         """Enable auto-instrumentation for network calls"""
         self.auto_instrument_network = True
+
+    def instrument_file_io_calls(self):
+        """Enable auto-instrumentation for file IO calls"""
+        self.auto_instrument_file_io = True

ragaai_catalyst/tracers/agentic_tracing/tracers/llm_tracer.py

@@ -61,6 +61,7 @@ class LLMTracerMixin:
         # Add auto_instrument options
         self.auto_instrument_llm = False
         self.auto_instrument_user_interaction = False
+        self.auto_instrument_file_io = False
         self.auto_instrument_network = False
 
     def instrument_llm_calls(self):
@@ -117,6 +118,10 @@ class LLMTracerMixin:
     def instrument_network_calls(self):
         """Enable network instrumentation for LLM calls"""
         self.auto_instrument_network = True
+        
+    def instrument_file_io_calls(self):
+        """Enable file IO instrumentation for LLM calls"""
+        self.auto_instrument_file_io = True
 
     def patch_openai_methods(self, module):
         try:
@@ -334,7 +339,17 @@ class LLMTracerMixin:
 
         interactions = []
         if self.auto_instrument_user_interaction:
-            interactions = self.component_user_interaction.get(component_id, [])
+            input_output_interactions = []
+            for interaction in self.component_user_interaction.get(component_id, []):
+                if interaction["interaction_type"] in ["input", "output"]:
+                    input_output_interactions.append(interaction)
+            interactions.extend(input_output_interactions) 
+        if self.auto_instrument_file_io:
+            file_io_interactions = []
+            for interaction in self.component_user_interaction.get(component_id, []):
+                if interaction["interaction_type"] in ["file_read", "file_write"]:
+                    file_io_interactions.append(interaction)
+            interactions.extend(file_io_interactions)
 
         parameters_to_display = {}
         if "run_manager" in parameters:

ragaai_catalyst/tracers/agentic_tracing/tracers/main_tracer.py

@@ -84,27 +84,23 @@ class AgenticTracing(
             self.auto_instrument_custom = True
         else:
             # Set global active state
-            self.is_active = (
-                any(auto_instrumentation.values())
-                if isinstance(auto_instrumentation, dict)
-                else bool(auto_instrumentation)
-            )
+            self.is_active = True
 
             # Set individual components
             if isinstance(auto_instrumentation, dict):
-                self.auto_instrument_llm = auto_instrumentation.get("llm", False)
-                self.auto_instrument_tool = auto_instrumentation.get("tool", False)
-                self.auto_instrument_agent = auto_instrumentation.get("agent", False)
+                self.auto_instrument_llm = auto_instrumentation.get("llm", True)
+                self.auto_instrument_tool = auto_instrumentation.get("tool", True)
+                self.auto_instrument_agent = auto_instrumentation.get("agent", True)
                 self.auto_instrument_user_interaction = auto_instrumentation.get(
-                    "user_interaction", False
+                    "user_interaction", True
                 )
                 self.auto_instrument_file_io = auto_instrumentation.get(
-                    "file_io", False
+                    "file_io", True
                 )
                 self.auto_instrument_network = auto_instrumentation.get(
-                    "network", False
+                    "network", True
                 )
-                self.auto_instrument_custom = auto_instrumentation.get("custom", False)
+                self.auto_instrument_custom = auto_instrumentation.get("custom", True)
             else:
                 # If boolean provided, apply to all components
                 self.auto_instrument_llm = bool(auto_instrumentation)
@@ -170,9 +166,6 @@ class AgenticTracing(
         self.user_interaction_tracer.trace_id.set(self.trace_id)
         self.user_interaction_tracer.tracer = self
         self.user_interaction_tracer.component_id.set(self.current_component_id.get())
-        builtins.print = self.user_interaction_tracer.traced_print
-        builtins.input = self.user_interaction_tracer.traced_input
-        builtins.open = self.user_interaction_tracer.traced_open
 
         # Start base tracer (includes system info and resource monitoring)
         super().start()
@@ -194,11 +187,12 @@ class AgenticTracing(
             self.instrument_custom_calls()
 
         if self.auto_instrument_user_interaction:
-
             ToolTracerMixin.instrument_user_interaction_calls(self)
             LLMTracerMixin.instrument_user_interaction_calls(self)
             AgentTracerMixin.instrument_user_interaction_calls(self)
             CustomTracerMixin.instrument_user_interaction_calls(self)
+            builtins.print = self.user_interaction_tracer.traced_print
+            builtins.input = self.user_interaction_tracer.traced_input
 
         if self.auto_instrument_network:
             ToolTracerMixin.instrument_network_calls(self)
@@ -206,9 +200,12 @@ class AgenticTracing(
             AgentTracerMixin.instrument_network_calls(self)
             CustomTracerMixin.instrument_network_calls(self)
 
-        # These will be implemented later
-        # if self.auto_instrument_file_io:
-        #     self.instrument_file_io_calls()
+        if self.auto_instrument_file_io:
+            ToolTracerMixin.instrument_file_io_calls(self)
+            LLMTracerMixin.instrument_file_io_calls(self)
+            AgentTracerMixin.instrument_file_io_calls(self)
+            CustomTracerMixin.instrument_file_io_calls(self)
+            builtins.open = self.user_interaction_tracer.traced_open
 
     def stop(self):
         """Stop tracing and save results"""

ragaai_catalyst/tracers/agentic_tracing/tracers/tool_tracer.py

@@ -32,6 +32,7 @@ class ToolTracerMixin:
         # add auto_instrument option
         self.auto_instrument_tool = False
         self.auto_instrument_user_interaction = False
+        self.auto_instrument_file_io = False
         self.auto_instrument_network = False
 
     # take care of auto_instrument
@@ -40,6 +41,9 @@ class ToolTracerMixin:
 
     def instrument_user_interaction_calls(self):
         self.auto_instrument_user_interaction = True
+        
+    def instrument_file_io_calls(self):
+        self.auto_instrument_file_io = True
 
     def instrument_network_calls(self):
         self.auto_instrument_network = True
@@ -133,6 +137,10 @@ class ToolTracerMixin:
         component_id = str(uuid.uuid4())
         hash_id = generate_unique_hash_simple(func)
 
+        # Set current tool name and store the token
+        name_token = self.current_tool_name.set(name)
+        id_token = self.current_tool_id.set(component_id)
+
         # Start tracking network calls for this component
         self.start_component(component_id)
 
@@ -191,6 +199,12 @@ class ToolTracerMixin:
             self.add_component(tool_component)
 
             raise
+        finally:
+            # Reset the tool name and id context
+            if name_token:
+                self.current_tool_name.reset(name_token)
+            if id_token:
+                self.current_tool_id.reset(id_token)
 
     async def _trace_tool_execution(
         self, func, name, tool_type, version, *args, **kwargs
@@ -207,6 +221,10 @@ class ToolTracerMixin:
         component_id = str(uuid.uuid4())
         hash_id = generate_unique_hash_simple(func)
 
+        # Set current tool name and store the token
+        name_token = self.current_tool_name.set(name)
+        id_token = self.current_tool_id.set(component_id)
+
         self.start_component(component_id)
         try:
             # Execute the tool
@@ -256,6 +274,12 @@ class ToolTracerMixin:
             self.add_component(tool_component)
 
             raise
+        finally:
+            # Reset the tool name and id context
+            if name_token:
+                self.current_tool_name.reset(name_token)
+            if id_token:
+                self.current_tool_id.reset(id_token)
 
     def create_tool_component(self, **kwargs):
         """Create a tool component according to the data structure"""
@@ -264,9 +288,19 @@ class ToolTracerMixin:
             network_calls = self.component_network_calls.get(kwargs["component_id"], [])
         interactions = []
         if self.auto_instrument_user_interaction:
-            interactions = self.component_user_interaction.get(
-                kwargs["component_id"], []
-            )
+            input_output_interactions = []
+            for interaction in self.component_user_interaction.get(kwargs["component_id"], []):
+                if interaction["interaction_type"] in ["input", "output"]:
+                    input_output_interactions.append(interaction)
+            if input_output_interactions!=[]:
+                interactions.extend(input_output_interactions) 
+        if self.auto_instrument_file_io:
+            file_io_interactions = []
+            for interaction in self.component_user_interaction.get(kwargs["component_id"], []):
+                if interaction["interaction_type"] in ["file_read", "file_write"]:
+                    file_io_interactions.append(interaction)
+            if file_io_interactions!=[]:
+                interactions.extend(file_io_interactions)
 
         # Get tags, metrics
         name = kwargs["name"]

ragaai_catalyst/tracers/agentic_tracing/utils/model_costs.json

@@ -2063,7 +2063,9 @@
         "input_cost_per_token": 5.9e-07,
         "output_cost_per_token": 7.9e-07,
         "litellm_provider": "groq",
-        "mode": "chat"
+        "mode": "chat",
+        "supports_function_calling": true,
+        "supports_response_schema": true
     },
     "groq/llama-3.3-70b-specdec": {
         "max_tokens": 8192,
@@ -4605,6 +4607,20 @@
         "litellm_provider": "replicate",
         "mode": "chat"
     },
+    "openrouter/deepseek/deepseek-r1": {
+        "max_tokens": 8192,
+        "max_input_tokens": 64000,
+        "max_output_tokens": 8192,
+        "input_cost_per_token": 5.5e-07,
+        "input_cost_per_token_cache_hit": 1.4e-07,
+        "output_cost_per_token": 2.19e-06,
+        "litellm_provider": "openrouter",
+        "mode": "chat",
+        "supports_function_calling": true,
+        "supports_assistant_prefill": true,
+        "supports_tool_choice": true,
+        "supports_prompt_caching": true
+    },
     "openrouter/deepseek/deepseek-chat": {
         "max_tokens": 8192,
         "max_input_tokens": 66000,

ragaai_catalyst/tracers/distributed.py

@@ -191,6 +191,7 @@ def trace_tool(name: str = None, tool_type: str = "generic", version: str = "1.0
     """Decorator for tracing tool functions."""
     def decorator(func):
         is_async = asyncio.iscoroutinefunction(func)
+        span_name = name or func.__name__
         
         @wraps(func)
         async def async_wrapper(*args, **kwargs):
@@ -198,15 +199,23 @@ def trace_tool(name: str = None, tool_type: str = "generic", version: str = "1.0
             if not tracer:
                 return await func(*args, **kwargs)
 
-            # Use async tool tracing
-            return await tracer._trace_tool_execution(
-                func,
-                name or func.__name__,
-                tool_type,
-                version,
-                *args,
-                **kwargs
-            )
+            # Set current tool name and store the token
+            name_token = tracer.current_tool_name.set(span_name)
+            
+            try:
+                # Use async tool tracing
+                return await tracer._trace_tool_execution(
+                    func,
+                    span_name,
+                    tool_type,
+                    version,
+                    *args,
+                    **kwargs
+                )
+            finally:
+                # Reset using the stored token
+                if name_token:
+                    tracer.current_tool_name.reset(name_token)
 
         @wraps(func)
         def sync_wrapper(*args, **kwargs):
@@ -214,15 +223,23 @@ def trace_tool(name: str = None, tool_type: str = "generic", version: str = "1.0
             if not tracer:
                 return func(*args, **kwargs)
 
-            # Use synchronous tool tracing
-            return tracer._trace_sync_tool_execution(
-                func,
-                name or func.__name__,
-                tool_type,
-                version,
-                *args,
-                **kwargs
-            )
+            # Set current tool name and store the token
+            name_token = tracer.current_tool_name.set(span_name)
+            
+            try:
+                # Use synchronous tool tracing
+                return tracer._trace_sync_tool_execution(
+                    func,
+                    span_name,
+                    tool_type,
+                    version,
+                    *args,
+                    **kwargs
+                )
+            finally:
+                # Reset using the stored token
+                if name_token:
+                    tracer.current_tool_name.reset(name_token)
 
         return async_wrapper if is_async else sync_wrapper
     return decorator
@@ -278,7 +295,17 @@ def current_span():
     if not tracer:
         return None
     
-    # Get the current agent name from context
+    # First check for LLM context
+    llm_name = tracer.current_llm_call_name.get()
+    if llm_name:
+        return tracer.span(llm_name)
+    
+    # Then check for tool context
+    tool_name = tracer.current_tool_name.get()
+    if tool_name:
+        return tracer.span(tool_name)
+    
+    # Finally fall back to agent context
     agent_name = tracer.current_agent_name.get()
     if not agent_name:
         raise ValueError("No active span found. Make sure you're calling this within a traced function.")

ragaai_catalyst/tracers/tracer.py

@@ -98,10 +98,10 @@ class Tracer(AgenticTracing):
                     "custom": False
                 }
         elif isinstance(auto_instrumentation, dict):
-            auto_instrumentation = {k: v for k, v in auto_instrumentation.items() if v}
+            auto_instrumentation = {k: v for k, v in auto_instrumentation.items()}
             for key in ["llm", "tool", "agent", "user_interaction", "file_io", "network", "custom"]:
                 if key not in auto_instrumentation:
-                    auto_instrumentation[key] = False
+                    auto_instrumentation[key] = True
         
         super().__init__(user_detail=user_detail, auto_instrumentation=auto_instrumentation)
 

{ragaai_catalyst-2.1.5b0.dist-info → ragaai_catalyst-2.1.5b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ragaai_catalyst
-Version: 2.1.5b0
+Version: 2.1.5b1
 Summary: RAGA AI CATALYST
 Author-email: Kiran Scaria <kiran.scaria@raga.ai>, Kedar Gaikwad <kedar.gaikwad@raga.ai>, Dushyant Mahajan <dushyant.mahajan@raga.ai>, Siddhartha Kosti <siddhartha.kosti@raga.ai>, Ritika Goel <ritika.goel@raga.ai>, Vijay Chaurasia <vijay.chaurasia@raga.ai>
 Requires-Python: <3.13,>=3.9

{ragaai_catalyst-2.1.5b0.dist-info → ragaai_catalyst-2.1.5b1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 ragaai_catalyst/__init__.py,sha256=tvESV8UuVtth14E89wQxgf0WvQZSApWfDeLiIdmMhkE,791
 ragaai_catalyst/_version.py,sha256=JKt9KaVNOMVeGs8ojO6LvIZr7ZkMzNN-gCcvryy4x8E,460
-ragaai_catalyst/dataset.py,sha256=aTRvZicAXmrC0KdmmsoJH_rtEJrxbqYmf1P806c1Wg0,10521
+ragaai_catalyst/dataset.py,sha256=Mc0L28lO4f7zD8DraQMHWzuizJf8Q0Z-DxNx3pS4OFo,23409
 ragaai_catalyst/evaluation.py,sha256=34H2bYZNSrcu0jMQgDZw1OLVbQU80PaVLo2avju8POM,20311
 ragaai_catalyst/experiment.py,sha256=8yQo1phCHlpnJ-4CqCaIbLXg_1ZlAuLGI9kqGBl-OTE,18859
 ragaai_catalyst/guard_executor.py,sha256=llPbE3DyVtrybojXknzBZj8-dtUrGBQwi9-ZiPJxGRo,3762
@@ -12,9 +12,9 @@ ragaai_catalyst/ragaai_catalyst.py,sha256=FdqMzwuQLqS2-3JJDsTQ8uh2itllOxfPrRUjb8
 ragaai_catalyst/synthetic_data_generation.py,sha256=uDV9tNwto2xSkWg5XHXUvjErW-4P34CTrxaJpRfezyA,19250
 ragaai_catalyst/utils.py,sha256=TlhEFwLyRU690HvANbyoRycR3nQ67lxVUQoUOfTPYQ0,3772
 ragaai_catalyst/tracers/__init__.py,sha256=LfgTes-nHpazssbGKnn8kyLZNr49kIPrlkrqqoTFTfc,301
-ragaai_catalyst/tracers/distributed.py,sha256=_KO7swUDoPErbfahxNSRpxQk22rstQItfPGP8e4l7E4,9334
+ragaai_catalyst/tracers/distributed.py,sha256=AIRvS5Ur4jbFDXsUkYuCTmtGoHHx3LOG4n5tWOh610U,10330
 ragaai_catalyst/tracers/llamaindex_callback.py,sha256=ZY0BJrrlz-P9Mg2dX-ZkVKG3gSvzwqBtk7JL_05MiYA,14028
-ragaai_catalyst/tracers/tracer.py,sha256=UX-01NYWcH2y4UW1W287Cn-jy760rgaFqu8llJbeMdg,15654
+ragaai_catalyst/tracers/tracer.py,sha256=S_ANRm5zSMvQiUyQTRwyUepFci_T3AN26wAOXoURfyc,15648
 ragaai_catalyst/tracers/upload_traces.py,sha256=mT5rverNUL5Rcal9VR5_c75wHBAUrm2pvYetTZqP3ok,4796
 ragaai_catalyst/tracers/agentic_tracing/README.md,sha256=X4QwLb7-Jg7GQMIXj-SerZIgDETfw-7VgYlczOR8ZeQ,4508
 ragaai_catalyst/tracers/agentic_tracing/__init__.py,sha256=yf6SKvOPSpH-9LiKaoLKXwqj5sez8F_5wkOb91yp0oE,260
@@ -27,14 +27,14 @@ ragaai_catalyst/tracers/agentic_tracing/tests/__init__.py,sha256=47DEQpj8HBSa-_T
 ragaai_catalyst/tracers/agentic_tracing/tests/ai_travel_agent.py,sha256=S4rCcKzU_5SB62BYEbNn_1VbbTdG4396N8rdZ3ZNGcE,5654
 ragaai_catalyst/tracers/agentic_tracing/tests/unique_decorator_test.py,sha256=Xk1cLzs-2A3dgyBwRRnCWs7Eubki40FVonwd433hPN8,4805
 ragaai_catalyst/tracers/agentic_tracing/tracers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ragaai_catalyst/tracers/agentic_tracing/tracers/agent_tracer.py,sha256=aLiq5nPie5TT61QYtvAtvErsxjPFYiUxjayn5aCX1_k,25543
-ragaai_catalyst/tracers/agentic_tracing/tracers/base.py,sha256=XZH5qi8eMIHG_qjedRHa3lGYp0NiAtCUxN9P_uW_NMo,39981
-ragaai_catalyst/tracers/agentic_tracing/tracers/custom_tracer.py,sha256=uay8lU7T-CKsVu8KvWX31qfMqufK9S3Ive7XKo2Ksmk,12252
+ragaai_catalyst/tracers/agentic_tracing/tracers/agent_tracer.py,sha256=--wvhOJ-J2433WPatIS3wx6VFeCUIcgRT5_ZjGQDv2c,26364
+ragaai_catalyst/tracers/agentic_tracing/tracers/base.py,sha256=RFHbmzFdkl1zV4ZnM6VOAnCeTMqSKmgdH8VuWsrBwf4,40120
+ragaai_catalyst/tracers/agentic_tracing/tracers/custom_tracer.py,sha256=l3x3uFO5ov93I7UUrUX1M06WVGy2ug2jEZ1G7o315z4,13075
 ragaai_catalyst/tracers/agentic_tracing/tracers/langgraph_tracer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ragaai_catalyst/tracers/agentic_tracing/tracers/llm_tracer.py,sha256=hU97LWEdqFL-tnIb_Qlk6VJdS6yVPH0QVzVzg1yuCB0,29341
-ragaai_catalyst/tracers/agentic_tracing/tracers/main_tracer.py,sha256=9K1swf0IOEEzgpkO2A_k_Yxk6ybLRXDcVoQAzm-_fWs,15889
+ragaai_catalyst/tracers/agentic_tracing/tracers/llm_tracer.py,sha256=fuSVks5-OchQLXqN6T18CtDjE8ufrCcksckcC3WW-_k,30150
+ragaai_catalyst/tracers/agentic_tracing/tracers/main_tracer.py,sha256=6hsg-Yw11v4qeELI1CWrdX8BXf-wJrTF5smBI5prgoo,15873
 ragaai_catalyst/tracers/agentic_tracing/tracers/network_tracer.py,sha256=m8CxYkl7iMiFya_lNwN1ykBc3Pmo-2pR_2HmpptwHWQ,10352
-ragaai_catalyst/tracers/agentic_tracing/tracers/tool_tracer.py,sha256=4h6epgRHPVRfTrCznwc6KPK6xevwBaZwE-q0Zj-4Kkk,12160
+ragaai_catalyst/tracers/agentic_tracing/tracers/tool_tracer.py,sha256=4rWL7fIJE5wN0nwh6fMWyh3OrrenZHJkNzyQXikyzQI,13771
 ragaai_catalyst/tracers/agentic_tracing/tracers/user_interaction_tracer.py,sha256=bhSUhNQCuJXKjgJAXhjKEYjnHMpYN90FSZdR84fNIKU,4614
 ragaai_catalyst/tracers/agentic_tracing/upload/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ragaai_catalyst/tracers/agentic_tracing/upload/upload_agentic_traces.py,sha256=1MDKXAAPzOEdxFKWWQrRgrmM3kz--DGXSywGXQmR3lQ,6041
@@ -47,7 +47,7 @@ ragaai_catalyst/tracers/agentic_tracing/utils/file_name_tracker.py,sha256=515NND
 ragaai_catalyst/tracers/agentic_tracing/utils/generic.py,sha256=WwXT01xmp8MSr7KinuDCSK9a1ifpLcT7ajFkvYviG_A,1190
 ragaai_catalyst/tracers/agentic_tracing/utils/get_user_trace_metrics.py,sha256=vPZ4dn4EHFW0kqd1GyRpsYXbfrRrd0DXCmh-pzsDBNE,1109
 ragaai_catalyst/tracers/agentic_tracing/utils/llm_utils.py,sha256=wlXCuaRe81s-7FWdJ_MquXFGRZZfNrZxLIIxl-Ohbqk,15541
-ragaai_catalyst/tracers/agentic_tracing/utils/model_costs.json,sha256=weznWpRd6N5X-O8lkzVA6nd5LSYJKa62s3GZL51NQpU,293833
+ragaai_catalyst/tracers/agentic_tracing/utils/model_costs.json,sha256=GXV1s349reRMpYF_EkK-b6peSb4SY-17WnlkvpuQ4sM,294430
 ragaai_catalyst/tracers/agentic_tracing/utils/span_attributes.py,sha256=MqeRNGxzeuh9qTK0NbYMftl9V9Z0V7gMgBoHkrXP56k,1592
 ragaai_catalyst/tracers/agentic_tracing/utils/trace_utils.py,sha256=RciiDdo2riibEoM8X0FKHaXi78y3bWwNkV8U0leqigk,3508
 ragaai_catalyst/tracers/agentic_tracing/utils/unique_decorator.py,sha256=DQHjcEuqEKsNSWaNs7SoOaq50yK4Jsl966S7mBnV-zA,5723
@@ -61,8 +61,8 @@ ragaai_catalyst/tracers/instrumentators/llamaindex.py,sha256=SMrRlR4xM7k9HK43hak
 ragaai_catalyst/tracers/instrumentators/openai.py,sha256=14R4KW9wQCR1xysLfsP_nxS7cqXrTPoD8En4MBAaZUU,379
 ragaai_catalyst/tracers/utils/__init__.py,sha256=KeMaZtYaTojilpLv65qH08QmpYclfpacDA0U3wg6Ybw,64
 ragaai_catalyst/tracers/utils/utils.py,sha256=ViygfJ7vZ7U0CTSA1lbxVloHp4NSlmfDzBRNCJuMhis,2374
-ragaai_catalyst-2.1.5b0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ragaai_catalyst-2.1.5b0.dist-info/METADATA,sha256=R0r0eV49WTeIO0O1NlkFk99eIbAPnvqf0urcA-GpF48,12764
-ragaai_catalyst-2.1.5b0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-ragaai_catalyst-2.1.5b0.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
-ragaai_catalyst-2.1.5b0.dist-info/RECORD,,
+ragaai_catalyst-2.1.5b1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ragaai_catalyst-2.1.5b1.dist-info/METADATA,sha256=raEM7cStptlPTu7ph3OyOU7UanQ3_7-T9dQbFXlFMbs,12764
+ragaai_catalyst-2.1.5b1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+ragaai_catalyst-2.1.5b1.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
+ragaai_catalyst-2.1.5b1.dist-info/RECORD,,