solace-agent-mesh 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

solace_agent_mesh/cli/commands/chat/chat.py

@@ -0,0 +1,361 @@
+import click
+import requests
+import os
+import json
+import pyperclip
+import uuid
+import base64
+import stat
+
+from ...utils import log_error
+from ...utils import log_link
+from ...utils import log_success
+
+XDG_CONFIG_HOME = os.getenv(
+    "XDG_CONFIG_HOME", os.path.expanduser("~/.config/solace_agent_mesh")
+)
+
+XDG_DOWNLOAD_DIR = os.getenv(
+    "XDG_DOWNLOAD_DIR", os.path.expanduser("~/Downloads/solace_agent_mesh")
+)
+
+TOKEN_FILE = os.path.join(XDG_CONFIG_HOME, "token.json")
+CONFIG_FILE = os.path.join(XDG_CONFIG_HOME, "setting.conf")
+
+
+def validate_token(server, access_token):
+    """
+    Validate the access token with the server.
+    """
+    response = requests.post(
+        f"{server}/is_token_valid",
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    return response.status_code
+
+
+def config_directory():
+    """
+    Get the configuration directory path.
+    """
+    return XDG_CONFIG_HOME
+
+
+def file_directory():
+    """
+    Get the file directory path.
+    """
+    return XDG_DOWNLOAD_DIR
+
+
+def set_permission(file_path):
+    """
+    Set file permissions to be readable and writable only by the owner.
+    """
+    os.chmod(file_path, stat.S_IRUSR | stat.S_IWUSR)
+
+
+def save_configuration(conf: dict):
+    """
+    Save the server address to the configuration file.
+    """
+    home_dir = config_directory()
+
+    # Create the home directory if it does not exist
+    os.makedirs(home_dir, exist_ok=True)
+
+    # Load existing configuration if it exists
+    if os.path.exists(CONFIG_FILE):
+        with open(CONFIG_FILE, "r") as f:
+            existing_conf = json.load(f)
+    else:
+        existing_conf = {}
+
+    # Update the existing configuration with new values
+    existing_conf.update(conf)
+
+    # Save the updated configuration
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(existing_conf, f)
+    set_permission(CONFIG_FILE)
+
+
+def save_files(files):
+    """
+    Save files to the file directory.
+    """
+    if files:
+        file_directory_path = file_directory()
+        os.makedirs(file_directory_path, exist_ok=True)
+        for file in files:
+            file_name = file["name"]
+            file_content = file["content"]
+            file_type = file["mime_type"]
+            if file_type.startswith("image/"):
+                # Decode Base64
+                file_content = base64.b64decode(file_content)
+            else:
+                file_content = file_content.encode("utf-8")
+
+            file_path = os.path.join(file_directory_path, file_name)
+            with open(file_path, "wb") as f:
+                f.write(file_content)
+            click.echo(f"File saved in {file_path}")
+
+
+def chat_command(chat):
+    """
+    Login and start a chat conversation.
+    """
+
+    @chat.command()
+    @click.argument("server")
+    def login(server):
+        """Log in to the solace-agent-mesh application."""
+        if not server:
+            log_error("Server address is required.")
+            return
+
+        # Save the server address
+        save_configuration({"auth_server": server})
+
+        try:
+            url = f"{server}/login"
+            click.secho(
+                "\U0001F447 Please authenticate by visiting the following URL:",
+                fg="green",
+            )
+            log_link(url)
+
+            click.prompt(
+                click.style(
+                    "\U0001F4C4 Copy the entire json object and press Enter (Ctrl+D to exit)",
+                    fg="green",
+                ),
+                default="",
+                show_default=False,
+            )
+
+            token = pyperclip.paste()
+
+            # Save the response as JSON
+            with open(TOKEN_FILE, "w") as f:
+                json.dump(json.loads(token), f)
+            set_permission(TOKEN_FILE)
+
+            token_data = json.loads(token)
+
+            # Verify the token
+            try:
+                status_code = validate_token(server, token_data.get("access_token"))
+                if status_code == 200:
+                    log_success("Login successful.")
+                else:
+                    log_error("Token is invalid or expired. Please log in again.")
+                    return
+            except requests.exceptions.RequestException as e:
+                log_error(f"Token validation failed: {e}")
+                return
+
+        except requests.exceptions.RequestException as e:
+            log_error(f"Login failed: {e}")
+
+    @chat.command()
+    def logout():
+        """Log out from the solace-agent-mesh application."""
+        if os.path.exists(TOKEN_FILE):
+            os.remove(TOKEN_FILE)
+            log_success("Logout successful.")
+        else:
+            log_error("No active session found.")
+
+    @chat.command()
+    @click.option(
+        "-s",
+        "--stream",
+        is_flag=True,
+        help="Stream mode.",
+        default=False,
+    )
+    @click.option(
+        "-a",
+        "--auth",
+        is_flag=True,
+        help="Enable authentication.",
+        default=False,
+    )
+    @click.option(
+        "-u",
+        "--url",
+        help="Chat endpoint url (e.g., https://<server>/api/v1/request).",
+    )
+    @click.option(
+        "-f",
+        "--file",
+        type=click.Path(exists=True, dir_okay=False, resolve_path=True),
+        multiple=True,
+        help="Attach files to the chat. Use -f or --file for each file.",
+    )
+    def start(stream, auth, url, file):
+        """Establish a chat with solace-agent-mesh plugin application."""
+
+        # Load the rest server address
+        rest_server = None
+        if url is not None:
+            # save the server address
+            rest_server = url
+            save_configuration({"rest_api_server": rest_server})
+        elif os.path.exists(CONFIG_FILE):
+            # load the server address from the configuration file
+            with open(CONFIG_FILE, "r") as f:
+                setting_data = json.load(f)
+                rest_server = setting_data.get("rest_api_server", None)
+        if rest_server is None:
+            rest_server = click.prompt(
+                click.style(
+                    "💬 Enter the server address (e.g., https://<server>/api/v1/request): ",
+                    fg="green",
+                )
+            )
+            # Save the server address
+            save_configuration({"rest_api_server": rest_server})
+
+        session_id = str(uuid.uuid4())
+        rest_endpoint_headers = {}
+
+        # Authenticate if it is enabled
+        if auth:
+            # Load authentication server
+            with open(CONFIG_FILE, "r") as f:
+                setting_data = json.load(f)
+                auth_server = setting_data.get("auth_server", "")
+                if not auth_server:
+                    log_error(
+                        "Authentication server not found. Please log in using 'sam login <server name>'."
+                    )
+                    return
+
+            # Load the token
+            if not os.path.exists(TOKEN_FILE):
+                log_error(
+                    "Token not found. Please log in using 'sam login <server name>'."
+                )
+                return
+
+            try:
+                with open(TOKEN_FILE, "r") as f:
+                    token_data = json.load(f)
+                    access_token = token_data.get("access_token")
+                    refresh_token = token_data.get("refresh_token")
+
+                    if access_token and refresh_token:
+                        # Validate token
+                        try:
+                            status_code = validate_token(auth_server, access_token)
+                            if status_code != 200:
+                                # Refresh token
+                                response = requests.post(
+                                    f"{auth_server}/refresh_token",
+                                    headers={
+                                        "Content-Type": "application/json",
+                                        "Authorization": f"Bearer {access_token}",
+                                    },
+                                    json={"refresh_token": refresh_token},
+                                )
+                                if response.status_code == 200:
+                                    access_token = response.json()
+                                else:
+                                    log_error(
+                                        "Failed to refresh token. Please log in again."
+                                    )
+                                    return
+                            rest_endpoint_headers = {
+                                "Authorization": f"Bearer {access_token}"
+                            }
+                        except requests.exceptions.RequestException as e:
+                            log_error(f"Token validation failed: {e}")
+                            return
+                    else:
+                        log_error(
+                            "Invalid token data. Please log in again using 'sam login <server name>'."
+                        )
+                        return
+            except Exception as e:
+                log_error(
+                    f"Token data not found: {e}. Please log in again using 'sam login <server name>'."
+                )
+                return
+
+        try:
+            files_to_send = []
+            if file:
+                for file_path in file:
+                    file_name = os.path.basename(file_path)
+                    files_to_send.append(("files", (file_name, open(file_path, "rb"))))
+
+            while True:
+                user_prompt = click.prompt(
+                    click.style("💬 How can I help you? (Ctrl+D to exit)", fg="green")
+                )
+                # Exit the chat
+                if user_prompt.lower() == "exit":
+                    break
+                    # Skip empty prompts
+                if not user_prompt.strip():
+                    continue
+
+                try:
+                    response = requests.post(
+                        f"{rest_server}",
+                        headers=rest_endpoint_headers,
+                        data={
+                            "prompt": user_prompt,
+                            "stream": stream,
+                            "session_id": session_id,
+                        },
+                        files=files_to_send,
+                    )
+                    response.raise_for_status()
+
+                    if stream:
+                        buffer = ""
+                        for chunk in response.iter_content(chunk_size=1):
+                            utf_chunk = chunk.decode("utf-8")
+                            buffer += utf_chunk
+
+                            while "\n\n" in buffer:
+                                split_chunk = buffer.split("\n\n", 1)
+                                data_chunk = split_chunk[0]
+                                buffer = split_chunk[1]
+
+                                if data_chunk == "data: [DONE]":
+                                    break
+                                data = json.loads(data_chunk[6:])
+                                content = data.get("content", "")
+                                if content:
+                                    click.echo(content, nl=False)
+                                status_message = data.get("status_message", "")
+                                if status_message:
+                                    click.secho(status_message, nl=True, fg="yellow")
+                                # Save files
+                                if "files" in data:
+                                    files = data["files"]
+                                    save_files(files)
+                    else:
+                        data = response.json()
+                        click.echo(f"{data['response']['content']}")
+                        # Save files
+                        if "files" in data["response"]:
+                            files = data["response"]["files"]
+                            save_files(files)
+                    click.echo("\n")
+
+                except requests.exceptions.RequestException as e:
+                    log_error(f"Request failed: {e}")
+                    return
+
+        except json.JSONDecodeError:
+            log_error(
+                "Sorry! I could not response to your request. Please try again later."
+            )
+            return

solace_agent_mesh/cli/commands/config.py

@@ -0,0 +1,29 @@
+import os
+import click
+
+from cli.config import Config
+from cli.utils import load_template, get_display_path
+
+
+def config_command():
+    """Update the config file with new default settings."""
+    config_path = Config.user_config_file
+
+    if not os.path.exists(config_path):
+        click.echo(
+            click.style(
+                (
+                    "No config file found. "
+                    "\n\tRun `solace-agent-mesh init` to generate a new config file."
+                ),
+                fg="yellow",
+            )
+        )
+        return 1
+
+    config = Config.get_config(config_path)
+    Config.write_config(config, config_path)
+
+    click.echo(
+        f"Config file updated with latest default configurations at {get_display_path(config_path)}"
+    )

solace_agent_mesh/cli/commands/init/__init__.py

@@ -0,0 +1,3 @@
+from .init import init_command
+
+__all__ = ["init_command"]

solace_agent_mesh/cli/commands/init/ai_provider_step.py

@@ -0,0 +1,76 @@
+import click
+
+from cli.utils import ask_if_not_provided
+
+
+def ai_provider_step(options, default_options, none_interactive, abort):
+    """
+    Initialize the AI provider.
+    """
+    ask_if_not_provided(
+        options,
+        "llm_endpoint_url",
+        "Provide LLM endpoint URL",
+        default_options["llm_endpoint_url"],
+        none_interactive,
+    )
+
+    ask_if_not_provided(
+        options,
+        "llm_api_key",
+        "Provide LLM API Key",
+        default_options["llm_api_key"],
+        none_interactive,
+        hide_input=True,
+    )
+    click.echo(
+        click.style(
+            (
+                "The model name should follow the format `provider/model-name`."
+                "\n\t For example: openai/gpt-4o or openai/my-model-that-follows-openai-api"
+            ),
+            fg="yellow",
+        )
+    )
+    ask_if_not_provided(
+        options,
+        "llm_model_name",
+        "Provide LLM model name to use",
+        default_options["llm_model_name"],
+        none_interactive,
+    )
+
+    ask_if_not_provided(
+        options,
+        "embedding_endpoint_url",
+        "Provide Embedding endpoint URL",
+        default_options["embedding_endpoint_url"],
+        none_interactive,
+    )
+
+    ask_if_not_provided(
+        options,
+        "embedding_api_key",
+        "Provide Embedding API Key",
+        default_options["embedding_api_key"],
+        none_interactive,
+        hide_input=True,
+    )
+
+    click.echo(
+        click.style(
+            (
+                "The model name should follow the format `provider/model-name`."
+                "\n\t For example: openai/text-embedding-ada-002 or openai/my-model-that-follows-openai-api"
+            ),
+            fg="yellow",
+        )
+    )
+
+    ask_if_not_provided(
+        options,
+        "embedding_model_name",
+        "Provide Embedding model name to use",
+        default_options["embedding_model_name"],
+        none_interactive,
+    )

solace_agent_mesh/cli/commands/init/broker_step.py

@@ -0,0 +1,102 @@
+import shutil
+import click
+import os
+
+from cli.utils import ask_if_not_provided
+
+
+CONTAINER_RUN_COMMAND = " run -d -p 8080:8080 -p 55554:55555 -p 8008:8008 -p 1883:1883 -p 8000:8000 -p 5672:5672 -p 9000:9000 -p 2222:2222 --shm-size=2g --env username_admin_globalaccesslevel=admin --env username_admin_password=admin --name=solace solace/solace-pubsub-standard"
+
+
+def broker_step(options, default_options, none_interactive, abort):
+    """
+    Initialize the broker.
+    """
+    broker_type = ask_if_not_provided(
+        options,
+        "broker_type",
+        (
+            "Which broker type do you want to use?\n"
+            "\t1) Existing Solace Pub/Sub+ broker\n"
+            "\t2) New local Solace PubSub+ broker container (podman/docker)\n"
+            "\t3) Run in 'dev mode' - all in one process (not recommended for production)\n"
+            "Enter the number of your choice"
+        ),
+        "1",
+        none_interactive,
+        ["1", "2", "3"],
+    )
+    if broker_type == "2" or broker_type == "container":
+        options["dev_mode"] = "false"
+        # Check if the user have podman or docker installed
+        has_podman = shutil.which("podman")
+        has_docker = shutil.which("docker")
+        if not has_podman and not has_docker:
+            abort(
+                "You need to have either podman or docker installed to use the container broker."
+            )
+
+        container_engine = "podman" if has_podman else "docker"
+        if has_podman and has_docker:
+            container_engine = ask_if_not_provided(
+                options,
+                "container_engine",
+                "Which container engine do you want to use?",
+                "podman",
+                none_interactive,
+                ["podman", "docker"],
+            )
+
+        # Run command for the container start
+        command = container_engine + CONTAINER_RUN_COMMAND
+        click.echo(
+            f"Running the Solace PubSub+ broker container using {container_engine}"
+        )
+        response_status = os.system(command)
+        if response_status != 0:
+            abort("Failed to start the Solace PubSub+ broker container.")
+
+        options["broker_url"] = default_options["broker_url"]
+        options["broker_vpn"] = default_options["broker_vpn"]
+        options["broker_username"] = default_options["broker_username"]
+        options["broker_password"] = default_options["broker_password"]
+
+    elif broker_type == "1" or broker_type == "solace":
+        options["dev_mode"] = "false"
+        ask_if_not_provided(
+            options,
+            "broker_url",
+            "Enter the Solace broker url endpoint",
+            default_options["broker_url"],
+            none_interactive,
+        )
+        ask_if_not_provided(
+            options,
+            "broker_vpn",
+            "Enter the Solace broker vpn name",
+            default_options["broker_vpn"],
+            none_interactive,
+        )
+        ask_if_not_provided(
+            options,
+            "broker_username",
+            "Enter the Solace broker username",
+            default_options["broker_username"],
+            none_interactive,
+        )
+        ask_if_not_provided(
+            options,
+            "broker_password",
+            "Enter the Solace broker password",
+            default_options["broker_password"],
+            none_interactive,
+            hide_input=True,
+        )
+
+    elif (
+        broker_type == "3" or
+        broker_type == "dev_broker" or
+        broker_type == "dev_mode" or
+        broker_type == "dev"
+    ):
+        options["dev_mode"] = "true"

solace_agent_mesh/cli/commands/init/builtin_agent_step.py

@@ -0,0 +1,88 @@
+from cli.utils import ask_if_not_provided
+
+
+def builtin_agent_step(options, default_options, none_interactive, abort):
+    """
+    Initialize the built-in agent.
+    """
+    agents = {
+        "web_request": (True, "can make queries to web to get real-time data", []),
+        "image_processing": (
+            True,
+            "generate images from text or convert images to text (The model name should be formatted like provider/model-name)",
+            ["IMAGE_GEN_MODEL=", "IMAGE_GEN_ENDPOINT=", "IMAGE_GEN_API_KEY="],
+        ),
+        "slack": (
+            False,
+            "Slack agent, send messages to Slack channels",
+            ["MONITOR_SLACK_BOT_TOKEN="],
+        ),
+    }
+
+    env_vars = {}
+    if "env_var" in options and options["env_var"]:
+        env_var_list = list(options["env_var"])
+        for env_var in env_var_list:
+            if "=" in env_var:
+                key, value = env_var.split("=")
+                env_vars[key] = value
+
+    if (
+        "built_in_agent" in options
+        and (
+            isinstance(options["built_in_agent"], tuple)
+            or isinstance(options["built_in_agent"], list)
+        )
+        and len(options["built_in_agent"]) > 0
+    ):
+        options["built_in_agent"] = list(options["built_in_agent"])
+        # Update env vars with default values
+        for name, agent in agents.items():
+            if name in options["built_in_agent"]:
+                for pair in agent[2]:
+                    key, value = pair.split("=")
+                    if key not in env_vars:
+                        env_vars[key] = value
+        options["env_var"] = [f"{key}={value}" for key, value in env_vars.items()]
+        return
+
+    if none_interactive:
+        selected_agents_list = [
+            agent for agent, (enabled, _, _), in agents.items() if enabled
+        ]
+        options["built_in_agent"] = selected_agents_list
+        # Update env vars with default values
+        for name, agent in agents.items():
+            if name in options["built_in_agent"]:
+                for pair in agent[2]:
+                    key, value = pair.split("=")
+                    if key not in env_vars:
+                        env_vars[key] = value
+        options["env_var"] = [f"{key}={value}" for key, value in env_vars.items()]
+        return
+
+    selected_agents = {}
+    for agent, (default, description, pairs) in agents.items():
+        enabled = ask_if_not_provided(
+            selected_agents,
+            agent,
+            f"Enable {agent} agent: {description}",
+            default,
+            none_interactive,
+        )
+        if enabled:
+            for pair in pairs:
+                key, value = pair.split("=")
+                ask_if_not_provided(
+                    env_vars,
+                    key,
+                    f'\tAgent "{agent}" requires env value "{key}":',
+                    value,
+                    none_interactive,
+                    hide_input="KEY" in key.upper(),
+                )
+    selected_agents_list = [
+        agent for agent, enabled in selected_agents.items() if enabled
+    ]
+    options["built_in_agent"] = selected_agents_list
+    options["env_var"] = [f"{key}={value}" for key, value in env_vars.items()]

solace_agent_mesh/cli/commands/init/check_if_already_done.py

@@ -0,0 +1,13 @@
+import os
+
+from cli.config import Config
+
+
+def check_if_already_done(options, default_options, none_interactive, abort):
+    """
+    Checks if the init command has already been done"""
+    config_path = Config.user_config_file
+    if os.path.exists(config_path):
+        abort(
+            "The project has already been initialized. If you want to reinitialize the project, please delete the solace-agent-mesh.yaml file."
+        )