fairo 25.7.2__tar.gz → 25.12.1__tar.gz

{fairo-25.7.2 → fairo-25.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fairo
-Version: 25.7.2
+Version: 25.12.1
 Summary: SDK for interfacing with Fairo SaaS platform.
 Author-email: "Fairo Systems, Inc." <support@fairo.ai>
 License: Apache-2.0
@@ -12,13 +12,11 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 Requires-Dist: mlflow<=3.1.1,>=3.1.0
-Requires-Dist: langchain<0.4.0,>=0.3.20
+Requires-Dist: langchain<0.4.0,>=0.3.27
 Requires-Dist: langchain-aws<0.3.0,>=0.2.18
-Requires-Dist: langchain-community<0.4.0,>=0.3.20
+Requires-Dist: langchain-community<0.4.0,>=0.3.27
 Requires-Dist: langchain-core<0.4.0,>=0.3.49
-Requires-Dist: langchain-text-splitters<0.4.0,>=0.3.7
-Requires-Dist: psycopg2-binary<3.0.0,>=2.9.0
-Requires-Dist: langchain-postgres<0.1.0,>=0.0.14
+Requires-Dist: langchain-text-splitters<0.4.0,>=0.3.11
 Requires-Dist: setuptools>=79.0.0
 Requires-Dist: pandas<3.0.0,>=2.0.0
 

fairo-25.12.1/fairo/__init__.py

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

{fairo-25.7.2 → fairo-25.12.1}/fairo/core/chat/chat.py

@@ -31,10 +31,10 @@ class FairoDeploymentClient(BaseDeploymentClient):
         
         # Add authentication if needed
         auth = None
-        if os.environ.get('MLFLOW_TRACKING_USERNAME') and os.environ.get('MLFLOW_TRACKING_PASSWORD'):
+        if os.environ.get('FAIRO_API_ACCESS_KEY_ID') and os.environ.get('FAIRO_API_SECRET'):
             auth = HTTPBasicAuth(
-                os.environ.get('MLFLOW_TRACKING_USERNAME'),
-                os.environ.get('MLFLOW_TRACKING_PASSWORD')
+                os.environ.get('FAIRO_API_ACCESS_KEY_ID'),
+                os.environ.get('FAIRO_API_SECRET')
             )
         
         # Make streaming request
@@ -116,12 +116,15 @@ class FairoDeploymentClient(BaseDeploymentClient):
         
         # Add authentication if needed
         auth = None
-        if os.environ.get('MLFLOW_TRACKING_USERNAME') and os.environ.get('MLFLOW_TRACKING_PASSWORD'):
+        if os.environ.get('FAIRO_API_ACCESS_KEY_ID') and os.environ.get('FAIRO_API_SECRET'):
             auth = HTTPBasicAuth(
-                os.environ.get('MLFLOW_TRACKING_USERNAME'),
-                os.environ.get('MLFLOW_TRACKING_PASSWORD')
+                os.environ.get('FAIRO_API_ACCESS_KEY_ID'),
+                os.environ.get('FAIRO_API_SECRET')
             )
         
+        if os.environ.get('MLFLOW_TRACKING_TOKEN'):
+            headers['Authorization'] = f"Bearer {os.environ.get('MLFLOW_TRACKING_TOKEN')}"
+        
         # Make request
         response = requests.post(
             gateway_url,
@@ -180,10 +183,6 @@ class ChatFairo(ChatMlflow):
 
     def __init__(self, **kwargs):
 
-        # # TODO <- see if this can be improved
-        # os.environ["MLFLOW_TRACKING_USERNAME"] = get_mlflow_user()
-        # os.environ["MLFLOW_TRACKING_PASSWORD"] = get_mlflow_password()
-
         super().__init__(
             target_uri=os.environ.get('MLFLOW_GATEWAY_URI', get_mlflow_gateway_uri()),
             endpoint=os.environ.get('MLFLOW_GATEWAY_ROUTE', get_mlflow_gateway_chat_route()),
@@ -194,17 +193,56 @@ class ChatFairo(ChatMlflow):
 
     @property
     def _target_uri(self):
-        return os.environ.get("MLFLOW_GATEWAY_URI", None)
+        return os.environ.get("MLFLOW_GATEWAY_URI", get_mlflow_gateway_uri())
 
     @property
     def _endpoint(self):
-        return os.environ.get("MLFLOW_GATEWAY_ROUTE", None)
+        return os.environ.get("MLFLOW_GATEWAY_ROUTE", get_mlflow_gateway_chat_route())
 
     def invoke(self, *args, **kwargs):
         # Override invoke to use dynamic target_uri
         self.target_uri = self._target_uri
         self._client = FairoDeploymentClient(self.target_uri, self.endpoint)
         return super().invoke(*args, **kwargs)
+    
+    def stream(self, *args, **kwargs):
+        # Override stream to use dynamic target_uri
+        self.target_uri = self._target_uri
+        self._client = FairoDeploymentClient(self.target_uri, self.endpoint)
+        return super().stream(*args, **kwargs)
+    
+    def bind_tools(self, tools, **kwargs):
+        result = super().bind_tools(tools, **kwargs)
+        result._uses_tools = True
+        return result
+    
+    def _stream(self, *args, **kwargs):
+        response = self.invoke(*args, **kwargs)
+        
+        from langchain_core.messages import AIMessage, AIMessageChunk
+        from langchain_core.outputs import ChatGenerationChunk
+        
+        if isinstance(response, AIMessage):
+            initial_chunk = AIMessageChunk(content="", role="assistant")
+            yield ChatGenerationChunk(message=initial_chunk)
+            
+            if response.content:
+                content_chunk = AIMessageChunk(content=response.content, role="assistant")
+                yield ChatGenerationChunk(message=content_chunk)
+            
+            if hasattr(response, 'tool_calls') and response.tool_calls:
+                tool_chunk = AIMessageChunk(
+                    content="", 
+                    role="assistant",
+                    tool_calls=response.tool_calls
+                )
+                yield ChatGenerationChunk(message=tool_chunk)
+            else:
+                final_chunk = AIMessageChunk(content="", role="assistant")
+                yield ChatGenerationChunk(message=final_chunk)
+        else:
+            chunk = AIMessageChunk(content=str(response), role="assistant")
+            yield ChatGenerationChunk(message=chunk)
 
 
 class FairoChat(ChatMlflow):

{fairo-25.7.2 → fairo-25.12.1}/fairo/core/client/client.py

@@ -3,10 +3,17 @@ import requests
 from requests.auth import HTTPBasicAuth
 
 class BaseClient:
-    def __init__(self, base_url: str, username: str, password: str):
+    def __init__(self, base_url: str, username: str = None, password: str = None, fairo_auth_token: str = None):
         self.base_url = base_url
         self.session = requests.Session()
-        self.session.auth = HTTPBasicAuth(username, password)
+        if username is not None and password is not None:
+            self.session.auth = HTTPBasicAuth(username, password)
+        elif fairo_auth_token is not None:
+            self.session.headers.update({
+                "Authorization": f"Bearer {fairo_auth_token}"
+            })
+        else:
+            raise ValueError("Must provide either username/password or fairo_auth_token")
         self.session.headers.update({
             "Content-Type": "application/json",
         })

{fairo-25.7.2 → fairo-25.12.1}/fairo/core/execution/agent_serializer.py

@@ -1,17 +1,42 @@
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 import mlflow
-import cloudpickle
-import os
-import sys
+import json
+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
@@ -53,27 +78,53 @@ class CustomPythonModel(mlflow.pyfunc.PythonModel):
         except ImportError as e:
             raise ImportError(f"Failed to import agent_code: {e}")
     
-    def predict(self, context, model_input):
+    def predict(self, context, model_input: list[str]):
         if isinstance(model_input, list):
-            return [self.agent.run(query) for query in model_input]
+            parsed_data = json.loads(model_input[0])
+            return self.run(parsed_data, callback_enabled=True)
         else:
-            return self.agent.run(model_input)
-
+            return self.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 +145,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 +159,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,8 +183,12 @@ class AgentChainWrapper:
         )
         return chain.run(result)
     
-    def predict(self, context = "", model_input = ""):
-        return self.run(model_input)
+    def predict(self, context = "", model_input: list[str] = [""]):
+        if isinstance(model_input, list):
+            parsed_data = json.loads(model_input[0])
+            return self.run(parsed_data, callback_enabled=True)
+        else:
+            return self.run(model_input)
 
 class CustomChainModel(mlflow.pyfunc.PythonModel):
     def __init__(self):
@@ -191,11 +255,12 @@ 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: list[str]):
         if isinstance(model_input, list):
-            return [self.agent_chain.run(query) for query in model_input]
+            parsed_data = json.loads(model_input[0])
+            return self.agent_chain.run(parsed_data)
         else:
             return self.agent_chain.run(model_input)
 
@@ -238,7 +303,7 @@ class CrewAgentWrapper:
             print(f"Error running CrewAI crew: {e}")
             return f"Error executing query '{query}': {str(e)}"
     
-    def predict(self, context, model_input):
+    def predict(self, context, model_input: list[str]):
         return self.run(model_input)
 
 class CustomCrewModel(mlflow.pyfunc.PythonModel):
@@ -281,8 +346,107 @@ class CustomCrewModel(mlflow.pyfunc.PythonModel):
         except ImportError as e:
             raise ImportError(f"Failed to import CrewAI agent_code: {e}")
     
-    def predict(self, context, model_input):
+    def predict(self, context, model_input: list[str]):
         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.7.2 → fairo-25.12.1}/fairo/core/execution/executor.py

@@ -1,10 +1,12 @@
 import json
 import os
-from typing import List, Any, Callable, Dict, Union
+from typing import List, Any, Callable, Dict, Optional, Type, Union
 from langchain_core.runnables import RunnableLambda, RunnableSequence
 from langchain.chains import SimpleSequentialChain
 import logging
 
+from pydantic import BaseModel
+
 import mlflow
 
 from mlflow.models.signature import ModelSignature
@@ -16,7 +18,7 @@ from fairo.core.execution.model_log_helper import ModelLogHelper
 from fairo.core.runnable.runnable import Runnable
 from fairo.core.workflow.utils import output_langchain_process_graph
 from fairo.settings import get_fairo_api_key, get_fairo_api_secret, get_mlflow_experiment_name, get_mlflow_server, get_fairo_base_url
-
+from fairo.core.tools import ChatSuggestions
 
 logger = logging.getLogger(__name__)
 
@@ -32,18 +34,24 @@ class FairoExecutor:
         experiment_name: str = None,
         chain_class = SimpleSequentialChain,
         input_fields: List[str] = [],
+        input_schema: Optional[Type[BaseModel]] = None,
+        chat_suggestions: Optional[ChatSuggestions] = None,
+        debug_mode: bool = False
     ):
         if agents and runnable:
             raise ValueError("FairoExecutor cannot be initialized with both 'agents' and 'runnable'. Please provide only one.")
-        if not input_fields:
-            raise ValueError("Missing input_fields")
+        if not input_fields and not input_schema:
+            raise ValueError("Missing required parameters: please provide at least one of 'input_fields' or 'input_schema'")
+        self.input_schema = input_schema
         self.agents = agents
         self.agent_type = agent_type
         self.verbose = verbose
+        self.debug_mode = debug_mode
         self.patch_run_output_json = patch_run_output_json
         self.workflow_run_id = workflow_run_id
         self.runnable = runnable
         self.experiment_name = experiment_name if experiment_name else get_mlflow_experiment_name()
+        self._setup_logging()
         self.setup_mlflow()
         self.chain_class = chain_class
         self.client = BaseClient(
@@ -51,6 +59,7 @@ class FairoExecutor:
             password=get_fairo_api_secret(),
             username=get_fairo_api_key()
         )
+        self.chat_suggestions = chat_suggestions
         self.input_fields = input_fields
         # Inject shared attributes into agents
         for agent in self.agents:
@@ -59,6 +68,14 @@ class FairoExecutor:
             if hasattr(agent, 'verbose'):
                 agent.verbose = self.verbose
 
+    def _setup_logging(self):
+        """Configure MLflow logging level based on debug_mode."""
+        mlflow_logger = logging.getLogger('mlflow')
+        if not self.debug_mode:
+            import warnings
+            warnings.filterwarnings('ignore', category=UserWarning)
+            mlflow_logger.setLevel(logging.ERROR)
+
     def _build_pipeline(self) -> RunnableSequence:
         if not self.agents and not self.runnable:
             raise ValueError("At least one agent or runnable must be provided.")
@@ -67,8 +84,26 @@ class FairoExecutor:
             pipeline = mlflow.pyfunc.load_model(self.runnable.artifact_path)
         else:
             pipeline = AgentChainWrapper(chain_class=self.chain_class, agent_functions_list=self.agents)
-            cols = [ColSpec(type="string", name=field) for field in self.input_fields]
-            input_schema = Schema(cols)
+            # Convert Pydantic schema to MLflow Schema
+            if hasattr(self.input_schema, 'model_json_schema'):
+                # Extract field names from Pydantic schema
+                pydantic_schema = self.input_schema.model_json_schema()
+                properties = pydantic_schema.get('properties', {})
+                cols = []
+                for field_name, field_info in properties.items():
+                    field_type = field_info.get('type', 'string')
+                    # Map Pydantic types to MLflow types
+                    mlflow_type = 'string'  # Default to string
+                    if field_type in ['integer', 'number']:
+                        mlflow_type = 'double'
+                    elif field_type == 'boolean':
+                        mlflow_type = 'boolean'
+                    cols.append(ColSpec(type=mlflow_type, name=field_name))
+                input_schema = Schema(cols)
+            else:
+                # Fallback to input_fields if schema is not Pydantic
+                cols = [ColSpec(type="string", name=field) for field in self.input_fields]
+                input_schema = Schema(cols)
 
             output_schema = Schema([
                 ColSpec(type="string", name="output"),
@@ -97,7 +132,9 @@ class FairoExecutor:
             fairo_settings = {
                 "type": type,
                 "process_graph": process_graph,
-                "input_schema": self.input_fields
+                "schema": self.input_schema.model_json_schema() if self.input_schema else None,
+                "input_fields": list(self.input_schema.model_fields.keys()) if self.input_schema else self.input_fields,
+                "chat_suggestions": self.chat_suggestions.model_dump() if self.chat_suggestions else None,
             }
             if process_graph:
                 mlflow.log_text(json.dumps(fairo_settings, ensure_ascii=False, indent=2), artifact_file="fairo_settings.txt")