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

solace_agent_mesh/cli/commands/chat/chat.py

@@ -1,361 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

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

solace_agent_mesh/cli/commands/init/ai_provider_step.py

@@ -1,93 +0,0 @@
-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 the user wants to enable the embedding service
-    embedding_enabled = ask_if_not_provided(
-        options,
-        "embedding_service_enabled",
-        "Enable embedding service for vector embeddings?",
-        default_options["embedding_service_enabled"],
-        none_interactive,
-    )
-
-    options["embedding_service_enabled"] = embedding_enabled
-
-    # Only ask for embedding configuration if the service is enabled
-    if embedding_enabled:
-        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,
-        )
-    else:
-        # Set empty values for embedding configuration if the service is disabled
-        options["embedding_endpoint_url"] = ""
-        options["embedding_api_key"] = ""
-        options["embedding_model_name"] = ""

solace_agent_mesh/cli/commands/init/broker_step.py

@@ -1,99 +0,0 @@
-import shutil
-import click
-import os
-
-from cli.utils import ask_if_not_provided
-from solace_agent_mesh.config_portal.backend.common import CONTAINER_RUN_COMMAND
-
-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

@@ -1,83 +0,0 @@
-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_ENDPOINT=", "IMAGE_GEN_API_KEY=", "IMAGE_GEN_MODEL=",],
-        ),
-    }
-
-    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

@@ -1,13 +0,0 @@
-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"
-        )