fairo 25.9.4__tar.gz → 25.9.5__tar.gz

{fairo-25.9.4 → fairo-25.9.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fairo
-Version: 25.9.4
+Version: 25.9.5
 Summary: SDK for interfacing with Fairo SaaS platform.
 Author-email: "Fairo Systems, Inc." <support@fairo.ai>
 License: Apache-2.0

fairo-25.9.5/fairo/__init__.py

@@ -0,0 +1 @@
+__version__ = "25.9.5"

{fairo-25.9.4 → fairo-25.9.5}/fairo/core/execution/agent_serializer.py

@@ -1,17 +1,41 @@
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 import mlflow
-import cloudpickle
-import os
-import sys
+from langchain.callbacks.base import BaseCallbackHandler
+from langchain_core.callbacks import CallbackManagerForChainRun
 from pathlib import Path
 from langchain_core.runnables import RunnableLambda, Runnable
 from langchain.chains import SimpleSequentialChain
 import logging
 import types
 import threading
+import inspect
 import pandas as pd
 logger = logging.getLogger(__name__)
 
+# Thread-local context for S3 client and bucket path to prevent cross-execution contamination
+import threading
+_agent_context = threading.local()
+
+def set_agent_context(s3_client, bucket_path, execution_id=None):
+    """Set thread-local context for agent execution"""
+    _agent_context.s3_client = s3_client
+    _agent_context.bucket_path = bucket_path
+    _agent_context.execution_id = execution_id
+
+def get_agent_context():
+    """Get thread-local context for agent execution"""
+    return {
+        's3_client': getattr(_agent_context, 's3_client', None),
+        'bucket_path': getattr(_agent_context, 'bucket_path', None),
+        'execution_id': getattr(_agent_context, 'execution_id', None)
+    }
+
+def clear_agent_context():
+    """Clear thread-local context to prevent memory leaks"""
+    for attr in ['s3_client', 'bucket_path', 'execution_id']:
+        if hasattr(_agent_context, attr):
+            delattr(_agent_context, attr)
+
 class CustomPythonModel(mlflow.pyfunc.PythonModel):
     def __init__(self):
         self.agent = None
@@ -60,20 +84,46 @@ class CustomPythonModel(mlflow.pyfunc.PythonModel):
             return self.agent.run(model_input)
 
 class AgentChainWrapper:
-    def __init__(self, chain_class = SimpleSequentialChain, agent_functions_list = []):
+    def __init__(self, chain_class = SimpleSequentialChain, agent_functions_list = [], callback_enabled = False):
         self.chain_class = chain_class
         self.agents = [func() for func in agent_functions_list]
         self.agent_functions = agent_functions_list
+        self.callback_enabled = callback_enabled
     
     def _wrap_agent_runnable(self, agent) -> RunnableLambda:
         """
         Wraps the agent's .run() method into a RunnableLambda with a custom function name.
         Properly propagates errors instead of continuing to the next agent.
         """
-        def base_fn(inputs: Dict[str, Any]) -> Dict[str, Any]:            
+        def base_fn(
+            x: Dict[str, Any],
+            *,
+            run_manager: CallbackManagerForChainRun = None,
+        ):
             # Run the agent, but don't catch exceptions - let them propagate
             # This will stop the entire pipeline on agent failure
-            return agent.invoke(inputs)
+            if run_manager:
+                run_manager.on_text(f"[{agent.__class__.__name__}] starting…")
+
+            # If your agent supports .invoke, prefer it; otherwise fall back to .run
+            try:
+                # Propagate callbacks to the inner agent call too (if it’s a Runnable)
+                if hasattr(agent, "invoke"):
+                    sig = inspect.signature(agent.invoke)
+                    if "config" in sig.parameters  and self.callback_enabled:
+                        out = agent.invoke(
+                            x,
+                            config={"callbacks": [OutputAgentStatus()]}
+                        )
+                    else:
+                        out = agent.invoke(x)
+                else:
+                    out = agent.run(x)  # legacy agents
+            finally:
+                if run_manager:
+                    run_manager.on_text(f"[{agent.__class__.__name__}] finished.")
+
+            return out
             
             # Check if result starts with "An error occurred" which indicates agent failure
             # if isinstance(result, str) and result.startswith("An error occurred during execution:"):
@@ -94,7 +144,9 @@ class AgentChainWrapper:
 
         return RunnableLambda(runnable_fn)
     
-    def run(self, query):
+    def run(self, query, callback_enabled: Optional[bool] = False):
+        if callback_enabled:
+            self.callback_enabled = callback_enabled
         result = query
         def is_dataframe(obj) -> bool:
             try:
@@ -106,7 +158,14 @@ class AgentChainWrapper:
         runnables = []
         for agent in self.agents:
             if isinstance(agent, Runnable):
-                runnables.append(agent)
+                # Check if agent supports with_config (Runnable style)
+                if hasattr(agent, "with_config") and self.callback_enabled:
+                    # Inject default callbacks on the agent itself
+                    enhanced = agent.with_config({"callbacks": [OutputAgentStatus()]})
+                    runnables.append(enhanced)
+                else:
+                    # Not a Runnable — wrap with your fallback wrapper
+                    runnables.append(agent)
             else:
                 runnables.append(
                     self._wrap_agent_runnable(agent)
@@ -123,7 +182,8 @@ class AgentChainWrapper:
         )
         return chain.run(result)
     
-    def predict(self, context = "", model_input = ""):
+    def predict(self, context = "", model_input = "", callback_enabled: Optional[bool] = False):
+        self.callback_enabled = callback_enabled
         return self.run(model_input)
 
 class CustomChainModel(mlflow.pyfunc.PythonModel):
@@ -191,9 +251,9 @@ class CustomChainModel(mlflow.pyfunc.PythonModel):
             agent_functions.append(agent_function)
         
         # Create the agent chain
-        self.agent_chain = AgentChainWrapper(agent_functions_list=agent_functions)
+        self.agent_chain = AgentChainWrapper(agent_functions_list=agent_functions, callback_enabled=True)
     
-    def predict(self, context, model_input):
+    def predict(self, context, model_input, callback_enabled: Optional[bool] = False):
         if isinstance(model_input, list):
             return [self.agent_chain.run(query) for query in model_input]
         else:
@@ -285,4 +345,103 @@ class CustomCrewModel(mlflow.pyfunc.PythonModel):
         if isinstance(model_input, list):
             return [self.agent.run(query) for query in model_input]
         else:
-            return self.agent.run(model_input)
+            return self.agent.run(model_input)
+
+
+class OutputAgentStatus(BaseCallbackHandler):
+    def __init__(self, s3_client=None, bucket_path=None):
+        super().__init__()
+        self.s3_client = s3_client
+        self.bucket_path = bucket_path
+
+        # If not provided, try to get from global context
+        if not self.s3_client or not self.bucket_path:
+            context = get_agent_context()
+            self.s3_client = self.s3_client or context.get('s3_client')
+            self.bucket_path = self.bucket_path or context.get('bucket_path')
+
+    def save_to_s3(self, status, message):
+        if not self.s3_client or not self.bucket_path:
+            return
+
+        # Validate execution_id is in bucket_path to prevent cross-execution contamination
+        import os
+        execution_id = os.environ.get('EXECUTION_ID')
+        if execution_id and execution_id not in self.bucket_path:
+            print(f"Warning: Execution ID {execution_id} not found in bucket path {self.bucket_path}. Skipping S3 write.")
+            return
+
+        try:
+            import os
+            import json
+            from datetime import datetime
+
+            bucket_name = os.environ.get('DEPLOYMENTS_BUCKET_NAME', 'local-development-deployments')
+            status_key = f"{self.bucket_path}/last_output.json"
+
+            # Try to read existing last_output.json
+            existing_data = {}
+            try:
+                response = self.s3_client.get_object(Bucket=bucket_name, Key=status_key)
+                existing_data = json.loads(response['Body'].read().decode('utf-8'))
+            except self.s3_client.exceptions.NoSuchKey:
+                # File doesn't exist yet, start with empty data
+                pass
+            except Exception as e:
+                print(f"Warning: Could not read existing last_output.json: {e}")
+
+            # Update the status and output fields
+            existing_data.update({
+                "status": status,
+                "output": message
+            })
+
+            # Save updated last_output.json
+            self.s3_client.put_object(
+                Bucket=bucket_name,
+                Key=status_key,
+                Body=json.dumps(existing_data),
+                ContentType='application/json'
+            )
+        except Exception as e:
+            print(f"Error saving status to S3: {e}")
+
+    def on_text(self, text: str, **kwargs):
+        self.save_to_s3("text_output", f"Agent generated text: {text}")
+
+    def on_llm_start(self, serialized, prompts, **kwargs):
+        model_name = serialized.get('name', 'Unknown')
+        self.save_to_s3("llm_start", f"Thinking")
+
+    def on_llm_new_token(self, token: str, **kwargs):
+        self.save_to_s3("llm_streaming", f"LLM generating response token: {token}")
+
+    def on_llm_end(self, response, **kwargs):
+        token_count = getattr(response, 'llm_output', {}).get('token_usage', {}).get('total_tokens', 'unknown')
+        self.save_to_s3("llm_complete", f"LLM completed response generation (tokens: {token_count})")
+
+    def on_tool_start(self, serialized, input_str: str, **kwargs):
+        tool_name = serialized.get('name', 'Unknown Tool')
+        self.save_to_s3("tool_start", f"Executing tool: {tool_name} with input: {input_str[:100]}")
+
+    def on_tool_end(self, output: str, **kwargs):
+        output_preview = str(output)[:100] if len(str(output)) > 100 else str(output)
+        self.save_to_s3("tool_complete", f"Tool execution completed with output: {output_preview}")
+
+    def on_chain_start(self, serialized, inputs, **kwargs):
+        chain_id = serialized.get('id', 'Unknown Chain')
+        self.save_to_s3("chain_start", f"Starting chain execution: {chain_id}")
+
+    def on_chain_end(self, outputs, **kwargs):
+        output_preview = str(outputs)[:100] if len(str(outputs)) > 100 else str(outputs)
+        self.save_to_s3("chain_complete", f"Chain execution completed with outputs: {output_preview}")
+
+    def on_agent_action(self, action, **kwargs):
+        action_tool = getattr(action, 'tool', 'Unknown')
+        action_input = getattr(action, 'tool_input', '')
+        self.save_to_s3("agent_action", f"Agent taking action with tool: {action_tool}, input: {str(action_input)[:100]}")
+
+    def on_agent_finish(self, finish, **kwargs):
+        return_values = getattr(finish, 'return_values', {})
+        output_preview = str(return_values)[:100] if len(str(return_values)) > 100 else str(return_values)
+        self.save_to_s3("agent_complete", f"Agent execution finished with result: {output_preview}")

{fairo-25.9.4 → fairo-25.9.5}/fairo/core/tools/plot.py

@@ -1,3 +1,7 @@
+import os
+from pathlib import Path
+import uuid
+from langchain_core.messages import ToolMessage
 from typing import Dict, List, Literal, Optional, Union
 from pydantic import BaseModel, Field, ConfigDict
 from enum import Enum
@@ -197,6 +201,18 @@ class PlotReturn(BaseModel):
     alt_text: Optional[str] = None
     debug: Optional[str] = None
 
+def save_to_png_file(base64_data: str):
+    artifact_id = uuid.uuid4()
+    base_dir = Path("/tmp") if Path("/tmp").exists() else Path.cwd()
+    file_path = base_dir / f"{artifact_id}.png"
+
+    if not os.path.exists(file_path):
+        # Decode base64 data and write as binary PNG file
+        png_data = base64.b64decode(base64_data)
+        with open(file_path, "wb") as f:
+            f.write(png_data)
+
+    return artifact_id
 
 @tool(args_schema=PlotSpec)
 def generate_plot(**kwargs) -> str:
@@ -217,8 +233,13 @@ def generate_plot(**kwargs) -> str:
                 f"{spec.chart_type} plot" if spec.chart_type else "Plot"
             )
         result = PlotReturn(data_base64=b64, alt_text=alt)
-        # Return a stringified JSON so the LLM can pass it through easily
-        return f"""data:{result.mime_type};base64,{result.data_base64}"""
+        # Save the base64 data as a PNG file
+        artifact_id = save_to_png_file(result.data_base64)
+        return ToolMessage(
+            content=f"Plot successfully generated",
+            artifact={"artifact_id": artifact_id, "artifact_type": "png"},
+            tool_call_id=uuid.uuid4()
+        )
     except Exception as e:
         # Return an error payload the orchestrator can handle
         err = PlotReturn(

fairo-25.9.5/fairo/core/utils.py

@@ -0,0 +1,260 @@
+import os
+import requests
+import mimetypes
+from typing import Optional, Dict, Any, Tuple
+from langchain_core.messages import ToolMessage
+from pathlib import Path
+from fairo.settings import get_fairo_base_url, get_fairo_api_key, get_fairo_api_secret
+from fairo.core.client.client import BaseClient
+
+
+def setup_fairo_client(base_url: Optional[str] = None) -> BaseClient:
+    """
+    Setup Fairo BaseClient with authentication.
+
+    Args:
+        base_url: Optional base URL, defaults to get_fairo_base_url()
+
+    Returns:
+        Configured BaseClient instance
+    """
+    api_base_url = base_url or get_fairo_base_url()
+    auth_token = os.environ.get("FAIRO_AUTH_TOKEN")
+    api_key = get_fairo_api_key()
+    api_secret = get_fairo_api_secret()
+
+    # Initialize client following the same pattern as FairoVectorStore
+    client = BaseClient(
+        base_url=api_base_url.rstrip('/'),
+        username=api_key,
+        password=api_secret,
+        fairo_auth_token=auth_token
+    )
+
+    return client
+
+
+def get_file_mimetype(file_path: Path) -> str:
+    """
+    Get the MIME type for a file based on its extension.
+
+    Args:
+        file_path: Path to the file
+
+    Returns:
+        MIME type string
+    """
+    mime_type, _ = mimetypes.guess_type(str(file_path))
+    return mime_type or 'application/octet-stream'
+
+
+def upload_file_to_fairo(
+    file_path: Path,
+    deployment_id: Optional[str] = None,
+    execution_id: Optional[str] = None,
+    base_url: Optional[str] = None
+) -> Optional[Tuple[str, str]]:
+    """
+    Upload a file to Fairo API using BaseClient authentication pattern.
+
+    Args:
+        file_path: Path to the file to upload
+        deployment_id: Optional deployment ID for deployment_artifacts endpoint
+        execution_id: Optional execution ID for deployment_artifacts endpoint
+        base_url: Optional base URL, defaults to get_fairo_base_url()
+
+    Returns:
+        Tuple of (file_id, file_url) if upload successful, None otherwise
+    """
+    if not file_path.exists():
+        return None
+
+    try:
+        # Setup client for authentication
+        api_base_url = base_url or get_fairo_base_url()
+        auth_token = os.environ.get("FAIRO_AUTH_TOKEN")
+        api_key = get_fairo_api_key()
+        api_secret = get_fairo_api_secret()
+
+        # Setup session with authentication (same pattern as BaseClient)
+        session = requests.Session()
+        if auth_token:
+            session.headers.update({"Authorization": f"Bearer {auth_token}"})
+        elif api_key and api_secret:
+            session.auth = requests.auth.HTTPBasicAuth(api_key, api_secret)
+        else:
+            raise ValueError("Must provide either FAIRO_AUTH_TOKEN or API credentials")
+
+        # Determine endpoint and data based on available IDs
+        if deployment_id and execution_id:
+            endpoint = f"{api_base_url.rstrip('/')}/deployment_artifacts"
+            upload_data = {
+                'deployment': deployment_id,
+                'execution_id': execution_id
+            }
+        else:
+            endpoint = f"{api_base_url.rstrip('/')}/files"
+            upload_data = {}
+
+        # Get file info
+        filename = file_path.name
+        mime_type = get_file_mimetype(file_path)
+
+        # Upload file
+        with open(file_path, 'rb') as file:
+            files = {'file_object': (filename, file, mime_type)}
+            response = session.post(
+                endpoint,
+                data=upload_data,
+                files=files
+            )
+            response.raise_for_status()
+
+            # Get the uploaded file information from response
+            upload_result = response.json()
+            file_id = upload_result.get("id") or upload_result.get("file_id")
+            file_url = upload_result.get("file_relative_url")
+
+            if file_id and file_url:
+                return file_id, f"{api_base_url.rstrip('/')}{file_url}"
+            else:
+                return None
+
+    except requests.exceptions.RequestException as e:
+        print(f"Failed to upload file {file_path}: {e}")
+        return None
+
+
+def process_artifact_file(
+    artifact_id: str,
+    file_extension: str = "html",
+    deployment_id: Optional[str] = None,
+    execution_id: Optional[str] = None
+) -> Optional[Dict[str, Any]]:
+    """
+    Process an artifact file by uploading it to Fairo API or returning file data.
+
+    Args:
+        artifact_id: ID of the artifact
+        file_extension: File extension (defaults to 'html')
+        deployment_id: Optional deployment ID
+        execution_id: Optional execution ID
+
+    Returns:
+        Message content dict or None if processing fails
+    """
+    # Setup file path
+    base_dir = Path("/tmp") if Path("/tmp").exists() else Path.cwd()
+    artifact_path = base_dir / f"{artifact_id}.{file_extension}"
+
+    if not artifact_path.exists():
+        return None
+
+    try:
+        # Try to upload file
+        upload_result = upload_file_to_fairo(
+            artifact_path,
+            deployment_id=deployment_id,
+            execution_id=execution_id
+        )
+
+        if upload_result:
+            file_id, file_url = upload_result
+            # Get mime type before cleaning up
+            mime_type = get_file_mimetype(artifact_path)
+
+            # Clean up local file after successful upload
+            artifact_path.unlink()
+
+            return {
+                "type": "file",
+                "mimeType": mime_type,
+                "url": file_url,
+                "id": file_id
+            }
+        else:
+            # Fallback to returning file data
+            mime_type = get_file_mimetype(artifact_path)
+            file_data = artifact_path.read_text(encoding="utf-8") if mime_type.startswith("text/") else artifact_path.read_bytes()
+
+            # Clean up local file
+            artifact_path.unlink()
+
+            return {
+                "type": "file",
+                "mimeType": mime_type,
+                "data": file_data
+            }
+
+    except Exception as e:
+        print(f"Error processing artifact {artifact_id}: {e}")
+
+        # Clean up local file in case of error
+        if artifact_path.exists():
+            artifact_path.unlink()
+
+        return None
+
+
+def parse_chat_interface_output(agent_executor_result):
+    """
+        Parses agent executor result into chat interface response
+        return_intermediate_steps must be set as true on the AgentExecutor in order to properly parse plot and suggestions
+    """
+    messages = [{"role": "assistant", "content": [
+                {
+                    "type": "text",
+                    "text": agent_executor_result["output"]
+                }
+            ]}]
+    suggestions = []
+    intermediate_steps = agent_executor_result.get('intermediate_steps', [])
+    for step, output  in intermediate_steps:
+        if step.tool == "send_chat_suggestions":
+            suggestions = output
+        
+        # Check if some tool message has artifact and raw_html attribute
+        artifact = None
+        is_tool_msg = isinstance(output, ToolMessage)
+        if is_tool_msg:
+            artifact = getattr(output, "artifact", None)
+            if artifact is None:
+                artifact = getattr(output, "additional_kwargs", {}).get("artifact")
+            if artifact:
+                artifact_id = artifact.get("artifact_id")
+                artifact_type = artifact.get("artifact_type", "html")  # Default to html for backward compatibility
+
+                if artifact_id:
+                    # Get environment variables
+                    deployment_id = os.environ.get("DEPLOYMENT_ID")
+                    execution_id = os.environ.get("EXECUTION_ID")
+
+                    # Process artifact using the new modular function
+                    content = process_artifact_file(
+                        artifact_id=artifact_id,
+                        file_extension=artifact_type,
+                        deployment_id=deployment_id,
+                        execution_id=execution_id
+                    )
+
+                    if content:
+                        # Create message with file ID in data field
+                        if "id" in content:
+                            messages.append({
+                                "role": "assistant",
+                                "content": [{
+                                    "type": "file",
+                                    "data": content["id"],
+                                    "mimeType": content["mimeType"]
+                                }]
+                            })
+                        else:
+                            # Fallback to original content structure
+                            messages.append({
+                                "role": "assistant",
+                                "content": [content]
+                            })
+    return {
+        "messages": messages,
+        "suggestions": suggestions
+    }

{fairo-25.9.4 → fairo-25.9.5}/fairo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fairo
-Version: 25.9.4
+Version: 25.9.5
 Summary: SDK for interfacing with Fairo SaaS platform.
 Author-email: "Fairo Systems, Inc." <support@fairo.ai>
 License: Apache-2.0

fairo-25.9.4/fairo/__init__.py

@@ -1 +0,0 @@
-__version__ = "25.9.4"

fairo-25.9.4/fairo/core/utils.py

@@ -1,54 +0,0 @@
-import os
-from langchain_core.messages import ToolMessage
-from pathlib import Path
-
-def parse_chat_interface_output(agent_executor_result):
-    """
-        Parses agent executor result into chat interface response
-        return_intermediate_steps must be set as true on the AgentExecutor in order to properly parse plot and suggestions
-    """
-    messages = [{"role": "assistant", "content": [
-                {
-                    "type": "text",
-                    "text": agent_executor_result["output"]
-                }
-            ]}]
-    suggestions = []
-    intermediate_steps = agent_executor_result.get('intermediate_steps', [])
-    for step, output  in intermediate_steps:
-        if step.tool == "generate_plot":
-            messages.append({"role": "assistant", "content": [
-                {
-                    "type": "image",
-                    "image": output
-                }
-            ]})
-        if step.tool == "send_chat_suggestions":
-            suggestions = output
-        
-        # Check if some tool message has artifact and raw_html attribute
-        artifact = None
-        is_tool_msg = isinstance(output, ToolMessage)
-        if is_tool_msg:
-            artifact = getattr(output, "artifact", None)
-            if artifact is None:
-                artifact = getattr(output, "additional_kwargs", {}).get("artifact")
-            if artifact:
-                artifact_id = artifact.get("artifact_id")
-                if artifact_id:
-                    base_dir = Path("/tmp") if Path("/tmp").exists() else Path.cwd()
-                    artifact_path = base_dir / f"{artifact_id}.html"
-                    messages.append({
-                        "role": "assistant",
-                        "content": [{
-                            "type": "file",
-                            "mimeType": "text/html",
-                            "data": artifact_path.read_text(encoding="utf-8")
-                        }]
-                    })
-                    if os.path.exists(artifact_path):
-                        os.remove(artifact_path)
-    return {
-        "messages": messages,
-        "suggestions": suggestions
-    }