solace-agent-mesh 1.6.1__py3-none-any.whl → 1.13.2__py3-none-any.whl

solace_agent_mesh/cli/commands/run_cmd.py

@@ -1,3 +1,4 @@
+import logging
 import os
 import sys
 from pathlib import Path
@@ -7,6 +8,7 @@ from dotenv import find_dotenv, load_dotenv
 
 from cli.utils import error_exit
 from solace_agent_mesh.common.utils.initializer import initialize
+from solace_ai_connector.common.logging_config import configure_from_file
 
 
 def _execute_with_solace_ai_connector(config_file_paths: list[str]):
@@ -62,12 +64,28 @@ def run(files: tuple[str, ...], skip_files: tuple[str, ...], system_env: bool):
     This command accepts paths to individual YAML files (`.yaml`, `.yml`) or directories.
     When a directory is provided, it is recursively searched for YAML files.
     """
-    click.echo(click.style("Starting Solace Application Run...", bold=True, fg="blue"))
+    # Set up initial logging to root logger (will be overwritten by LOGGING_CONFIG_PATH if provided)
+    log = None
+    reset_logging = True
+
+    def _setup_backup_logger():
+        nonlocal log
+        if not log:
+            log = logging.getLogger()
+            handler = logging.StreamHandler(sys.stdout)
+            formatter = logging.Formatter(
+                "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+            )
+            handler.setFormatter(formatter)
+            log.addHandler(handler)
+            log.setLevel(logging.INFO)
+        return log
+        
+    env_path = ""
 
     if not system_env:
         env_path = find_dotenv(usecwd=True)
         if env_path:
-            click.echo(f"Loading environment variables from: {env_path}")
             load_dotenv(dotenv_path=env_path, override=True)
 
             # Resolve LOGGING_CONFIG_PATH to absolute path if it's relative
@@ -76,22 +94,24 @@ def run(files: tuple[str, ...], skip_files: tuple[str, ...], system_env: bool):
                 absolute_logging_path = os.path.abspath(logging_config_path)
                 os.environ["LOGGING_CONFIG_PATH"] = absolute_logging_path
 
-            # Reconfigure logging now that environment variables are loaded
-            try:
-                from solace_ai_connector.common.log import reconfigure_logging
-                if reconfigure_logging():
-                    click.echo("Logging reconfigured from LOGGING_CONFIG_PATH")
-            except ImportError:
-                pass  # solace_ai_connector might not be available yet
+    try:
+        if configure_from_file():
+            log = logging.getLogger(__name__)
+            log.info("Logging reconfigured from LOGGING_CONFIG_PATH")
+            reset_logging = False
         else:
-            click.echo(
-                click.style(
-                    "Warning: .env file not found in the current directory or parent directories. Proceeding without loading .env.",
-                    fg="yellow",
-                )
-            )
+            log = _setup_backup_logger()
+    except ImportError:
+        log = _setup_backup_logger()  # solace_ai_connector might not be available yet
+        log.warning("Using backup logger; solace_ai_connector not available.")
+
+    if system_env:
+        log.warning("Skipping .env file loading due to --system-env flag.")
     else:
-        click.echo("Skipping .env file loading due to --system-env flag.")
+        if not env_path:
+            log.warning("Warning: .env file not found in the current directory or parent directories. Proceeding without loading .env.")
+        else:
+            log.info("Loaded environment variables from: %s", env_path)
 
     # Run enterprise initialization if present
     initialize()
@@ -101,16 +121,13 @@ def run(files: tuple[str, ...], skip_files: tuple[str, ...], system_env: bool):
     configs_dir = project_root / "configs"
 
     if not files:
-        click.echo(
-            f"No specific files provided. Discovering YAML files in {configs_dir}..."
+        log.info(
+            "No specific files provided. Discovering YAML files in %s...", configs_dir
         )
         if not configs_dir.is_dir():
-            click.echo(
-                click.style(
-                    f"Error: Configuration directory '{configs_dir}' not found. Please run 'init' first or provide specific config files.",
-                    fg="red",
-                ),
-                err=True,
+            log.error(
+                "Error: Configuration directory '%s' not found. Please run 'init' first or provide specific config files.",
+                configs_dir
             )
             sys.exit(1)
 
@@ -118,8 +135,8 @@ def run(files: tuple[str, ...], skip_files: tuple[str, ...], system_env: bool):
             if filepath.name.startswith("_") or filepath.name.startswith(
                 "shared_config"
             ):
-                click.echo(
-                    f"  Skipping discovery: {filepath} (underscore prefix or shared_config)"
+                log.info(
+                    "  Skipping discovery: %s (underscore prefix or shared_config)", filepath
                 )
                 continue
             config_files_to_run.append(str(filepath.resolve()))
@@ -128,27 +145,27 @@ def run(files: tuple[str, ...], skip_files: tuple[str, ...], system_env: bool):
             if filepath.name.startswith("_") or filepath.name.startswith(
                 "shared_config"
             ):
-                click.echo(
-                    f"  Skipping discovery: {filepath} (underscore prefix or shared_config)"
+                log.info(
+                    "  Skipping discovery: %s (underscore prefix or shared_config)", filepath
                 )
                 continue
             if str(filepath.resolve()) not in config_files_to_run:
                 config_files_to_run.append(str(filepath.resolve()))
 
     else:
-        click.echo("Processing provided configuration files and directories:")
+        log.info("Processing provided configuration files and directories:")
         processed_files = set()
         for path_str in files:
             path = Path(path_str)
             if path.is_dir():
-                click.echo(f"  Discovering YAML files in directory: {path}")
+                log.info("  Discovering YAML files in directory: %s", path)
                 for yaml_ext in ("*.yaml", "*.yml"):
                     for filepath in path.rglob(yaml_ext):
                         if filepath.name.startswith("_") or filepath.name.startswith(
                             "shared_config"
                         ):
-                            click.echo(
-                                f"  Skipping discovery: {filepath} (underscore prefix or shared_config)"
+                            log.info(
+                                "  Skipping discovery: %s (underscore prefix or shared_config)", filepath
                             )
                             continue
                         processed_files.add(str(filepath.resolve()))
@@ -156,45 +173,43 @@ def run(files: tuple[str, ...], skip_files: tuple[str, ...], system_env: bool):
                 if path.suffix in [".yaml", ".yml"]:
                     processed_files.add(str(path.resolve()))
                 else:
-                    click.echo(
-                        click.style(f"  Ignoring non-YAML file: {path}", fg="yellow")
+                    log.warning(
+                        "  Ignoring non-YAML file: %s", path
                     )
         config_files_to_run = sorted(list(processed_files))
 
     if skip_files:
-        click.echo(f"Applying --skip for: {skip_files}")
+        log.info("Applying --skip for: %s", skip_files)
         final_list = []
         skipped_basenames = [os.path.basename(s) for s in skip_files]
         for cf in config_files_to_run:
             if os.path.basename(cf) in skipped_basenames:
-                click.echo(
-                    f"  Skipping execution: {cf} (due to --skip)"
+                log.info(
+                    "  Skipping execution: %s (due to --skip)", cf
                 )
                 continue
             final_list.append(cf)
         config_files_to_run = final_list
 
     if not config_files_to_run:
-        click.echo(
-            click.style(
-                "No configuration files to run after filtering. Exiting.", fg="yellow"
-            )
+        log.warning(
+            "No configuration files to run after filtering. Exiting."
         )
         return 0
 
-    click.echo(click.style("Final list of configuration files to run:", bold=True))
-    for cf_path_str in config_files_to_run:
-            click.echo(f"  - {cf_path_str}")
+    file_list = "\n".join(f"  - {cf}" for cf in config_files_to_run)
+    log.info("Final list of configuration files to run:\n%s", file_list)
 
+    if reset_logging:
+        for handler in log.handlers[:]:
+            log.removeHandler(handler)
     return_code = _execute_with_solace_ai_connector(config_files_to_run)
 
     if return_code == 0:
-        click.echo(click.style("Application run completed successfully.", fg="green"))
+        log.info("Application run completed successfully.")
     else:
-        click.echo(
-            click.style(
-                f"Application run failed or exited with code {return_code}.", fg="red"
-            )
+        log.error(
+            "Application run failed or exited with code %s.", return_code
         )
 
     sys.exit(return_code)

solace_agent_mesh/cli/commands/tools_cmd.py

@@ -0,0 +1,315 @@
+import click
+import json
+from typing import Optional, List, Dict, Any
+from collections import defaultdict
+
+# Import to trigger tool registration
+import solace_agent_mesh.agent.tools  # noqa: F401
+from solace_agent_mesh.agent.tools.registry import tool_registry
+from cli.utils import error_exit
+
+
+def format_parameter_schema(schema) -> str:
+    """
+    Format the parameter schema into a readable string.
+
+    Args:
+        schema: A google.genai.types.Schema object
+
+    Returns:
+        Formatted string representation of parameters
+    """
+    if not schema or not hasattr(schema, 'properties') or not schema.properties:
+        return "  No parameters"
+
+    lines = []
+    required = schema.required if hasattr(schema, 'required') else []
+
+    for prop_name, prop_schema in schema.properties.items():
+        is_required = prop_name in required
+        req_str = "required" if is_required else "optional"
+        type_str = getattr(prop_schema, 'type', 'unknown')
+        desc = getattr(prop_schema, 'description', '')
+        lines.append(f"  - {prop_name} ({type_str}, {req_str}): {desc}")
+
+    return "\n".join(lines)
+
+
+def format_tool_table_brief(tools: List) -> None:
+    """
+    Format tools as a brief list and echo to console.
+
+    Groups tools by category and displays only names and descriptions.
+
+    Args:
+        tools: List of BuiltinTool objects
+    """
+    if not tools:
+        click.echo("No tools found.")
+        return
+
+    # Group tools by category
+    tools_by_category = defaultdict(list)
+    for tool in tools:
+        tools_by_category[tool.category].append(tool)
+
+    # Sort categories alphabetically
+    sorted_categories = sorted(tools_by_category.keys())
+
+    total_tools = len(tools)
+
+    for category in sorted_categories:
+        category_tools = sorted(tools_by_category[category], key=lambda t: t.name)
+
+        # Get category metadata from first tool in category
+        first_tool = category_tools[0]
+        category_name = first_tool.category_name or category
+
+        # Display category header
+        click.echo()
+        click.echo(click.style(f"═══ {category_name} ═══", bold=True, fg='cyan'))
+        click.echo()
+
+        # Display tools in category (brief format)
+        for tool in category_tools:
+            click.echo(f"  • {click.style(tool.name, bold=True, fg='green')}")
+            # Wrap description at 70 characters
+            desc_words = tool.description.split()
+            lines = []
+            current_line = "    "
+            for word in desc_words:
+                if len(current_line) + len(word) + 1 <= 74:
+                    current_line += (" " if len(current_line) > 4 else "") + word
+                else:
+                    lines.append(current_line)
+                    current_line = "    " + word
+            if current_line.strip():
+                lines.append(current_line)
+            for line in lines:
+                click.echo(line)
+            click.echo()
+
+    # Display summary
+    click.echo(click.style(f"Total: {total_tools} tool{'s' if total_tools != 1 else ''}", bold=True, fg='blue'))
+
+
+def format_tool_table(tools: List) -> None:
+    """
+    Format tools as a detailed table and echo to console.
+
+    Groups tools by category and displays detailed information for each tool.
+
+    Args:
+        tools: List of BuiltinTool objects
+    """
+    if not tools:
+        click.echo("No tools found.")
+        return
+
+    # Group tools by category
+    tools_by_category = defaultdict(list)
+    for tool in tools:
+        tools_by_category[tool.category].append(tool)
+
+    # Sort categories alphabetically
+    sorted_categories = sorted(tools_by_category.keys())
+
+    total_tools = len(tools)
+
+    for category in sorted_categories:
+        category_tools = sorted(tools_by_category[category], key=lambda t: t.name)
+
+        # Get category metadata from first tool in category
+        first_tool = category_tools[0]
+        category_name = first_tool.category_name or category
+        category_desc = first_tool.category_description or ""
+
+        # Display category header
+        header_width = 60
+        click.echo()
+        click.echo("╭" + "─" * (header_width - 2) + "╮")
+        click.echo("│ " + click.style(category_name, bold=True, fg='cyan') +
+                  " " * (header_width - len(category_name) - 3) + "│")
+        if category_desc:
+            # Wrap description if needed
+            desc_lines = []
+            current_line = ""
+            for word in category_desc.split():
+                if len(current_line) + len(word) + 1 <= header_width - 4:
+                    current_line += (" " if current_line else "") + word
+                else:
+                    desc_lines.append(current_line)
+                    current_line = word
+            if current_line:
+                desc_lines.append(current_line)
+
+            for desc_line in desc_lines:
+                click.echo("│ " + desc_line + " " * (header_width - len(desc_line) - 3) + "│")
+        click.echo("╰" + "─" * (header_width - 2) + "╯")
+        click.echo()
+
+        # Display tools in category
+        for tool in category_tools:
+            click.echo(click.style(f"Tool: {tool.name}", bold=True, fg='green'))
+            click.echo(f"Description: {tool.description}")
+
+            # Format and display parameters
+            click.echo("Parameters:")
+            params_str = format_parameter_schema(tool.parameters)
+            click.echo(params_str)
+
+            # Display required scopes
+            if tool.required_scopes:
+                scopes_str = ", ".join(tool.required_scopes)
+                click.echo(f"Required Scopes: {click.style(scopes_str, fg='yellow')}")
+            else:
+                click.echo("Required Scopes: None")
+
+            click.echo()  # Blank line between tools
+
+    # Display summary
+    click.echo(click.style(f"Total: {total_tools} tool{'s' if total_tools != 1 else ''}",
+                          bold=True, fg='blue'))
+
+
+def tools_to_json(tools: List, detailed: bool = False) -> str:
+    """
+    Convert tools list to JSON format.
+
+    Args:
+        tools: List of BuiltinTool objects
+        detailed: If True, include parameters and all metadata. If False, only name and description.
+
+    Returns:
+        JSON string representation of tools
+    """
+    result = []
+
+    for tool in tools:
+        if detailed:
+            # Convert Schema to dict if possible
+            try:
+                if hasattr(tool.parameters, 'model_dump'):
+                    params_dict = tool.parameters.model_dump()
+                elif hasattr(tool.parameters, 'to_dict'):
+                    params_dict = tool.parameters.to_dict()
+                else:
+                    # Fallback: manually construct dict from Schema
+                    params_dict = {
+                        "type": getattr(tool.parameters, 'type', None),
+                        "properties": {},
+                        "required": getattr(tool.parameters, 'required', [])
+                    }
+                    if hasattr(tool.parameters, 'properties') and tool.parameters.properties:
+                        for prop_name, prop_schema in tool.parameters.properties.items():
+                            params_dict["properties"][prop_name] = {
+                                "type": getattr(prop_schema, 'type', None),
+                                "description": getattr(prop_schema, 'description', '')
+                            }
+            except Exception:
+                params_dict = {"error": "Could not serialize parameters"}
+
+            tool_dict = {
+                "name": tool.name,
+                "description": tool.description,
+                "category": tool.category,
+                "category_name": tool.category_name,
+                "category_description": tool.category_description,
+                "required_scopes": tool.required_scopes,
+                "parameters": params_dict,
+                "examples": tool.examples,
+                "raw_string_args": tool.raw_string_args
+            }
+        else:
+            # Brief format: only name and description
+            tool_dict = {
+                "name": tool.name,
+                "description": tool.description,
+                "category": tool.category,
+                "category_name": tool.category_name
+            }
+
+        result.append(tool_dict)
+
+    return json.dumps(result, indent=2)
+
+
+@click.group("tools")
+def tools():
+    """Manage and explore SAM built-in tools."""
+    pass
+
+
+@tools.command("list")
+@click.option(
+    "--category", "-c",
+    type=str,
+    default=None,
+    help="Filter tools by category (e.g., 'artifact_management', 'data_analysis')"
+)
+@click.option(
+    "--detailed", "-d",
+    is_flag=True,
+    help="Show detailed information including parameters and required scopes"
+)
+@click.option(
+    "--json", "output_json",
+    is_flag=True,
+    help="Output in JSON format instead of pretty table"
+)
+def list_tools(category: Optional[str], detailed: bool, output_json: bool):
+    """
+    List all built-in tools available in Solace Agent Mesh.
+
+    By default, shows brief information with tool names and descriptions.
+    Use --detailed flag to see parameters and required scopes.
+
+    Examples:
+
+        # List all tools (brief)
+        sam tools list
+
+        # List with full details
+        sam tools list --detailed
+
+        # Filter by category
+        sam tools list --category artifact_management
+
+        # Detailed view with category filter
+        sam tools list -c web --detailed
+
+        # Output as JSON
+        sam tools list --json
+
+        # Filter and output as JSON
+        sam tools list -c web --json
+    """
+    # Fetch tools from registry
+    if category:
+        tools_list = tool_registry.get_tools_by_category(category)
+        if not tools_list:
+            # Get all categories to show valid options
+            all_tools = tool_registry.get_all_tools()
+            if not all_tools:
+                error_exit("No tools are registered in the tool registry.")
+
+            categories = sorted(set(t.category for t in all_tools))
+            error_exit(
+                f"No tools found for category '{category}'.\n"
+                f"Valid categories: {', '.join(categories)}"
+            )
+    else:
+        tools_list = tool_registry.get_all_tools()
+        if not tools_list:
+            error_exit("No tools are registered in the tool registry.")
+
+    # Output based on format preference
+    if output_json:
+        json_output = tools_to_json(tools_list, detailed=detailed)
+        click.echo(json_output)
+    else:
+        # Use detailed format only if --detailed flag is provided
+        if detailed:
+            format_tool_table(tools_list)
+        else:
+            format_tool_table_brief(tools_list)

solace_agent_mesh/cli/main.py

@@ -1,6 +1,12 @@
 import click
 import os
 import sys
+import warnings
+
+_suppress_warnings = "--suppress-warnings" in sys.argv
+if _suppress_warnings:
+    warnings.simplefilter("ignore")
+    sys.argv.remove("--suppress-warnings")
 
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 sys.path.append(os.path.dirname(SCRIPT_DIR))
@@ -12,12 +18,20 @@ from cli.commands.add_cmd import add
 from cli.commands.plugin_cmd import plugin
 from cli.commands.eval_cmd import eval_cmd
 from cli.commands.docs_cmd import docs
+from cli.commands.tools_cmd import tools
 
 
 @click.group(context_settings=dict(help_option_names=['-h', '--help']))
 @click.version_option(
     __version__, "-v", "--version", help="Show the CLI version and exit."
 )
+@click.option(
+    '--suppress-warnings',
+    is_flag=True,
+    expose_value=False,
+    is_eager=True,
+    help="Suppress warnings emitted by Python's warnings module."
+)
 def cli():
     """Solace CLI Application"""
     pass
@@ -29,6 +43,7 @@ cli.add_command(add)
 cli.add_command(plugin)
 cli.add_command(eval_cmd)
 cli.add_command(docs)
+cli.add_command(tools)
 
 
 def main():

solace_agent_mesh/client/webui/frontend/static/assets/{authCallback-BTf6dqwp.js → authCallback-KnKMP_vb.js}

@@ -1 +1 @@
-import{c as n}from"./client-CaY59VuC.js";import{r as a,j as s}from"./vendor-BEmvJSYz.js";function c(){return a.useEffect(()=>{const r=window.location.hash.substring(1),e=new URLSearchParams(r),o=e.get("access_token"),t=e.get("refresh_token");o?(localStorage.setItem("access_token",o),t&&localStorage.setItem("refresh_token",t),window.location.href="/"):console.error("AuthCallback: No access token found in URL hash.")},[]),s.jsx("div",{children:"Loading..."})}n.createRoot(document.getElementById("root")).render(s.jsx(c,{}));
+import{c as n}from"./client-DpBL2stg.js";import{r as a,j as s}from"./vendor-CGk8Suyh.js";function c(){return a.useEffect(()=>{const r=window.location.hash.substring(1),e=new URLSearchParams(r),o=e.get("access_token"),t=e.get("refresh_token");o?(localStorage.setItem("access_token",o),t&&localStorage.setItem("refresh_token",t),window.location.href="/"):console.error("AuthCallback: No access token found in URL hash.")},[]),s.jsx("div",{children:"Loading..."})}n.createRoot(document.getElementById("root")).render(s.jsx(c,{}));