solace-agent-mesh 0.2.4__py3-none-any.whl → 1.0.2__py3-none-any.whl

solace_agent_mesh/common/mysql_database.py

@@ -1,40 +0,0 @@
-"""Manage a MySQL database connection."""
-
-import mysql.connector
-
-class MySQLDatabase:
-    def __init__(self, host: str, user: str, password: str, database: str):
-        self.host = host
-        self.user = user
-        self.password = password
-        self.database = database
-        self.connection = None
-
-        if ":" in self.host:
-            self.host, self.port = self.host.split(":")
-        else:
-            self.port = 3306
-
-    def cursor(self, **kwargs):
-        if self.connection is None:
-            self.connect()
-        try:
-            return self.connection.cursor(**kwargs)
-        except mysql.connector.errors.OperationalError:
-            self.connect()
-            return self.connection.cursor(**kwargs)
-
-    def connect(self):
-        return mysql.connector.connect(
-            host=self.host,
-            port=self.port,
-            user=self.user,
-            password=self.password,
-            database=self.database,
-            raise_on_warnings=False,
-            connection_timeout=60,
-            autocommit=True,
-        )
-
-    def close(self):
-        self.connection.close()

solace_agent_mesh/common/postgres_database.py

@@ -1,85 +0,0 @@
-"""Manage a PostgreSQL database connection."""
-
-import psycopg2
-import psycopg2.extras
-from solace_ai_connector.common.log import log
-
-
-class PostgreSQLDatabase:
-    def __init__(self, host: str, user: str, password: str, database: str):
-        self.host = host
-        self.user = user
-        self.password = password
-        self.database = database
-        self.connection = None
-
-        if ":" in self.host:
-            self.host, self.port = self.host.split(":")
-        else:
-            self.port = 5432
-
-    def cursor(self, **kwargs):
-        if self.connection is None or self.connection.closed:
-            self.connect()
-        try:
-            return self.connection.cursor(**kwargs)
-        except Exception:  # pylint: disable=broad-except
-            self.connect()
-            return self.connection.cursor(**kwargs)
-
-    def connect(self, auto_commit=True):
-        self.connection = psycopg2.connect(
-            host=self.host,
-            port=self.port,
-            user=self.user,
-            password=self.password,
-            database=self.database,
-            connect_timeout=10,
-        )
-        self.connection.autocommit = auto_commit
-
-    def close(self):
-        self.connection.close()
-
-    def execute(self, query, params=None):
-        sanity = 3
-        while True:
-            try:
-                cursor = self.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
-                cursor.execute(query, params)
-                break
-            except Exception as e:
-                log.error("Database error: %s", e)
-                sanity -= 1
-                if sanity == 0:
-                    raise e
-
-        return cursor
-
-def get_db_for_action(action_obj, sql_params=None):
-    if sql_params:
-        sql_host = sql_params.get("sql_host")
-        sql_user = sql_params.get("sql_user")
-        sql_password = sql_params.get("sql_password")
-        sql_database = sql_params.get("sql_database")
-    else:
-        sql_host = action_obj.get_config("sql_host")
-        sql_user = action_obj.get_config("sql_user")
-        sql_password = action_obj.get_config("sql_password")
-        sql_database = action_obj.get_config("sql_database")
-    sql_db = None
-
-    if sql_host and sql_user and sql_password and sql_database:
-        sql_db = PostgreSQLDatabase(
-            host=sql_host,
-            user=sql_user,
-            password=sql_password,
-            database=sql_database,
-        )
-
-    if sql_db is None:
-        raise ValueError(
-            f"SQL database expected but not configured on {action_obj.__class__.__name__}"
-        )
-
-    return sql_db

solace_agent_mesh/common/prompt_templates.py

@@ -1,28 +0,0 @@
-from typing import List
-import yaml
-
-
-def FilterLocationsSystemPrompt(locations: List[str]) -> str:
-    return f"""
-You will use your geographical knowledge to filter the following list of locations
-into a list of locations that fall within the user's request. Those locations
-must be returned in a yaml array of the following schema:
-
-<response-schema-yaml>
-matching_locations:
-  - <location1>
-  - <location2>
-  ...
-</response-schema-yaml>
-
-<locations>
-{yaml.dump(locations)}
-"""
-
-
-def FilterLocationsUserPrompt(location_filter: str) -> str:
-    return f"""
-<user-location-filter>
-{location_filter}
-</user-location-filter>
-"""

solace_agent_mesh/common/stimulus_utils.py

@@ -1,152 +0,0 @@
-"""Utilities for describing stimulus state and events.
-
-This module provides functions for generating human-readable descriptions
-of stimulus state, including events, errors and completion status.
-"""
-
-from typing import Dict, List
-import time
-import json
-
-from solace_ai_connector.common.log import log
-from ..services.file_service import FileService
-
-
-def _format_timestamp(timestamp: float) -> str:
-    """Formats a Unix timestamp into a human readable string.
-
-    Args:
-        timestamp: Unix timestamp to format
-
-    Returns:
-        Formatted timestamp string in YYYY-MM-DD HH:MM:SS format
-    """
-    return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(timestamp))
-
-
-def _format_event(event: Dict) -> str:
-    """Formats a single stimulus event into markdown.
-
-    Args:
-        event: Dictionary containing event details including topic, payload,
-            user properties and timestamp
-
-    Returns:
-        Markdown formatted string describing the event
-    """
-    timestamp = _format_timestamp(event.get("timestamp", 0))
-    topic = event.get("topic", "")
-    payload = event.get("payload", {})
-    user_props = event.get("user_properties", {})
-
-    # Format based on topic pattern, similar to ConversationFormatter
-    if "/stimulus/" in topic:
-        stimulus_text = payload.get("text", "")
-        identity = user_props.get("identity", "unknown")
-        if "/reinvoke" in topic:
-            return f"### {timestamp} - Reinvoke Request\nFrom: {identity}\n```\n{stimulus_text}\n```\n"
-        return f"### {timestamp} - Initial Request\nFrom: {identity}\n```\n{stimulus_text}\n```\n"
-
-    if "/response/" in topic or "/streamingResponse/" in topic:
-        if isinstance(payload, dict) and payload.get("last_chunk") is True:
-            response_text = payload.get("text", "")
-            return f"### {timestamp} - Response:\n{response_text}\n\n"
-        return ""
-
-    if "/responseComplete/" in topic:
-        return f"### {timestamp} - Response Complete\n"
-
-    if "/actionRequest/" in topic:
-        action_name = payload.get("action_name", "")
-        action_params = payload.get("action_params", {})
-        params_text = "\n".join(f"- {k}: {v}" for k, v in action_params.items())
-        return f"### {timestamp} - Action Request: {action_name}\n{params_text}\n"
-
-    if "/actionResponse/" in topic:
-        topic_parts = topic.split("/agent/")[1].split("/")
-        agent_name = topic_parts[0]
-        action_name = topic_parts[1]
-        response_text = "\n".join(f"- {k}: {v}" for k, v in payload.items())
-        return f"### {timestamp} - Action Response: {agent_name}.{action_name}\n{response_text}\n"
-
-    return f"### {timestamp} - Other Event\nTopic: {topic}\n"
-
-
-def _format_error(error: Dict) -> str:
-    """Formats a single stimulus error into markdown.
-
-    Args:
-        error: Dictionary containing error details including message,
-            timestamp and user properties
-
-    Returns:
-        Markdown formatted string describing the error
-    """
-    timestamp = _format_timestamp(error.get("timestamp", 0))
-    message = error.get("message", "Unknown error")
-    source = error.get("source", "Unknown source")
-    return f"### {timestamp} - Error\nSource: {source}\nDetails: {message}\n"
-
-
-def describe_stimulus(stimulus_uuid: str, state: Dict, is_timeout: bool = False) -> str:
-    """Generates a markdown description of a stimulus's complete state.
-
-    Takes a stimulus state dictionary and generates a human-readable markdown
-    description including all events, errors and completion status.
-
-    Args:
-        stimulus_uuid: UUID of the stimulus
-        state: Dictionary containing complete stimulus state including events,
-            errors and metadata
-        is_timeout: Whether this stimulus timed out
-
-    Returns:
-        Markdown formatted string describing the complete stimulus journey
-    """
-    events: List[Dict] = state.get("events", [])
-    errors: List[Dict] = state.get("errors", [])
-    completion_status = state.get("completion_status", "unknown")
-
-    # Start with header
-    description = f"# Stimulus {stimulus_uuid}\n\n"
-
-    # Add completion status with timeout indicator if applicable
-    status_str = completion_status.upper()
-    if is_timeout:
-        status_str += " (TIMED OUT)"
-    description += f"**Status:** {status_str}\n\n"
-
-    # Add events section
-    if events:
-        description += "## Events\n\n"
-        for event in events:
-            description += _format_event(event)
-
-    # Add errors section
-    if errors:
-        description += "\n## Errors\n\n"
-        for error in errors:
-            description += _format_error(error)
-
-    # Add any available files
-    available_files_json = (
-        events[-1].get("user_properties", {}).get("available_files", None)
-    )
-    available_files = []
-    if available_files_json:
-        try:
-            available_files_user_prop = json.loads(available_files_json)
-            if available_files_user_prop:
-                file_service = FileService()
-                available_files = [
-                    file_service.get_file_block_by_metadata(file)
-                    for file in available_files_user_prop
-                ]
-        except Exception as e:
-            log.error("Failed to get available files: %s", str(e))
-
-        if available_files:
-            description += "\n## Available Files\n\n"
-            description += "\n\n".join(available_files)
-
-    return description

solace_agent_mesh/common/time.py

@@ -1,24 +0,0 @@
-ONE_DAY = 86400
-"""
-Number of seconds in a day.
-"""
-
-ONE_HOUR = 3600
-"""
-Number of seconds in an hour.
-"""
-
-THIRTY_MINUTES = 1800
-"""
-Number of seconds in thirty minutes.
-"""
-
-TEN_MINUTES = 600
-"""
-Number of seconds in ten minutes.
-"""
-
-FIVE_MINUTES = 300
-"""
-Number of seconds in five minutes.
-"""