ibm-watsonx-orchestrate 1.0.0__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/channels/types.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+class  EnvironmentType(str, Enum):
+    DRAFT ='draft'
+    LIVE = 'live'
+
+    def __str__(self):
+        return self.value
+    
+
+class  ChannelType(str, Enum):
+    WEBCHAT ='webchat'
+
+    def __str__(self):
+        return self.value

ibm_watsonx_orchestrate/cli/commands/channels/webchat/channels_webchat_command.py

@@ -0,0 +1,32 @@
+import typer
+from typing_extensions import Annotated
+from ibm_watsonx_orchestrate.cli.commands.channels.types import EnvironmentType
+from ibm_watsonx_orchestrate.cli.commands.channels.webchat.channels_webchat_controller import ChannelsWebchatController
+
+
+channel_webchat = typer.Typer(no_args_is_help=True)
+
+@channel_webchat.command(
+    name="embed",
+    help="Creates an embedded webchat code snippet with the command 'orchestrate channel webchat embed --agent-name=some_agent --env=live"
+)
+def create_webchat_embed_code(
+    agent_name: Annotated[
+        str,
+        typer.Option(
+            '--agent-name',
+            '-a',
+            help='The name of the agent you wish to have embedded'
+        )
+    ],
+    env: Annotated[
+        EnvironmentType,
+        typer.Option(
+            '--env',
+            '-e',
+            help='The environment in which your agent resides. This will default to live if no environment is provided'
+        )
+    ] = EnvironmentType.LIVE,
+):
+    controller = ChannelsWebchatController(agent_name=agent_name, env=env)
+    controller.create_webchat_embed_code()

ibm_watsonx_orchestrate/cli/commands/channels/webchat/channels_webchat_controller.py

@@ -0,0 +1,141 @@
+import logging
+import logging
+import rich
+import jwt
+
+from ibm_watsonx_orchestrate.cli.config import Config, ENV_WXO_URL_OPT, ENVIRONMENTS_SECTION_HEADER, CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT, CHAT_UI_PORT
+from ibm_watsonx_orchestrate.client.utils import is_local_dev, AUTH_CONFIG_FILE_FOLDER, AUTH_SECTION_HEADER, AUTH_MCSP_TOKEN_OPT, AUTH_CONFIG_FILE
+
+from ibm_watsonx_orchestrate.client.agents.agent_client import AgentClient
+
+from ibm_watsonx_orchestrate.client.utils import instantiate_client
+
+logger = logging.getLogger(__name__)
+
+class ChannelsWebchatController:
+    def __init__(self, agent_name: str, env: str):
+        self.agent_name = agent_name
+        self.env = env
+
+    def get_native_client(self):
+        self.native_client = instantiate_client(AgentClient)
+        return self.native_client
+
+
+    def get_agent_id(self, agent_name: str):
+        native_client = self.get_native_client()
+        existing_native_agents = native_client.get_draft_by_name(agent_name)
+
+        if not existing_native_agents:
+            logger.error(f"No agent found with the name '{agent_name}'")
+            exit(1)
+        agent_id = existing_native_agents[0]['id']
+        return agent_id
+
+    def get_environment_id(self, agent_name: str, env: str):
+        native_client = self.get_native_client()
+        existing_native_agents = native_client.get_draft_by_name(agent_name)
+
+        if not existing_native_agents:
+            raise ValueError(f"No agent found with the name '{agent_name}'")
+
+        agent = existing_native_agents[0]
+        agent_environments = agent.get("environments", [])
+
+        is_local = is_local_dev()
+        target_env = env or 'draft'
+
+        if is_local:
+            if env == 'live':
+                logger.warning('Live environments do not exist for Local env, defaulting to draft.')
+            target_env = 'draft'
+
+        filtered_environments = [e for e in agent_environments if e.get("name") == target_env]
+
+        if not filtered_environments:
+            if env == 'live':
+                logger.error(f'This agent does not exist in the {env} environment. You need to deploy it to {env} before you can embed the agent')
+            exit(1)
+
+        return filtered_environments[0].get("id")
+
+
+    def get_tennent_id(self):
+        auth_cfg = Config(AUTH_CONFIG_FILE_FOLDER, AUTH_CONFIG_FILE)
+
+        cfg = Config()
+        active_env = cfg.read(CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT)
+        is_local = is_local_dev()
+
+        existing_auth_config = auth_cfg.get(AUTH_SECTION_HEADER).get(active_env, {})
+
+        existing_token = existing_auth_config.get(AUTH_MCSP_TOKEN_OPT) if existing_auth_config else None
+
+        token = jwt.decode(existing_token, options={"verify_signature": False})
+        tenant_id = ""
+        if is_local:
+            tenant_id = token.get('woTenantId', None)
+        else:
+            tenant_id = token.get('tenantId', None)
+
+        return tenant_id
+
+    def get_host_url(self):
+        cfg = Config()
+        active_env = cfg.read(CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT)
+        env_cfg = cfg.get(ENVIRONMENTS_SECTION_HEADER, active_env)
+        url = env_cfg.get(ENV_WXO_URL_OPT)
+        is_local = is_local_dev(url=url)
+        if is_local:
+            url_parts = url.split(":")
+            url_parts[-1] = CHAT_UI_PORT
+            url = ":".join(url_parts)
+            return url
+        else:
+            if url.startswith("https://api."):
+                url = url.replace("https://api.", "https://", 1)
+            cleaned_url = url.split(".com")[0] + ".com"
+
+            return cleaned_url
+
+            
+    def create_webchat_embed_code(self):
+        tenant_id = self.get_tennent_id()
+        host_url = self.get_host_url()
+        agent_id = self.get_agent_id(self.agent_name)
+        agent_env_id = self.get_environment_id(self.agent_name, self.env)
+
+        is_local = is_local_dev()
+        script_path = (
+            "/wxoLoader.js?embed=true"
+            if is_local
+            else "/wxochat/wxoLoader.js?embed=true"
+        )
+
+        script = f"""
+            <script>
+                window.wxOConfiguration = {{
+                    orchestrationID: "{tenant_id}",
+                    hostURL: "{host_url}",
+                    rootElementID: "root",
+                    showLauncher: true,
+                    chatOptions: {{
+                        agentId: "{agent_id}",
+                        agentEnvironmentId: "{agent_env_id}"
+                    }},
+                }};
+
+                setTimeout(function () {{
+                    const script = document.createElement('script');
+                    script.src = `${{window.wxOConfiguration.hostURL}}{script_path}`;
+                    script.addEventListener('load', function () {{
+                    wxoLoader.init();
+                    }});
+                    document.head.appendChild(script);
+                }}, 0);
+            </script>
+        """ 
+
+        rich.print(script)
+        return script
+

ibm_watsonx_orchestrate/cli/commands/chat/chat_command.py

@@ -0,0 +1,43 @@
+import logging
+import typer
+import webbrowser
+from pathlib import Path
+
+chat_app = typer.Typer(no_args_is_help=True)
+from ibm_watsonx_orchestrate.cli.commands.server.server_command import run_compose_lite_ui, run_compose_lite_down_ui
+
+logger = logging.getLogger(__name__)
+
+@chat_app.command(name="start")
+def chat_start(
+    user_env_file: str = typer.Option(
+        None,
+        "--env-file", "-e",
+        help="Path to a .env file that overrides default.env. Then environment variables override both."
+    )
+):
+    user_env_file_path = Path(user_env_file) if user_env_file else None
+
+    is_ui_service_started = run_compose_lite_ui(user_env_file=user_env_file_path)
+
+    if is_ui_service_started:
+        url = "http://localhost:3000/chat-lite"
+        webbrowser.open(url)
+        logger.info(f"Opening chat interface at {url}")
+    else:
+        logger.error("Unable to start orchestrate UI chat service.  Please check error messages and logs")
+
+@chat_app.command(name="stop")
+def chat_stop(
+    user_env_file: str = typer.Option(
+        None,
+        "--env-file", "-e",
+        help="Path to a .env file that overrides default.env. Then environment variables override both."
+    )
+):
+    user_env_file_path = Path(user_env_file) if user_env_file else None
+    run_compose_lite_down_ui(user_env_file=user_env_file_path)
+
+
+if __name__ == "__main__":
+    chat_app()

ibm_watsonx_orchestrate/cli/commands/connections/connections_command.py

@@ -0,0 +1,307 @@
+import typer
+from typing_extensions import Annotated, List
+from ibm_watsonx_orchestrate.agent_builder.connections.types import ConnectionEnvironment, ConnectionPreference, ConnectionKind
+from ibm_watsonx_orchestrate.cli.commands.connections.connections_controller import (
+    add_connection,
+    remove_connection,
+    list_connections,
+    import_connection,
+    configure_connection,
+    set_credentials_connection,
+    set_identity_provider_connection
+)
+
+connections_app = typer.Typer(no_args_is_help=True)
+
+@connections_app.command(name="add")
+def add_connection_command(
+    app_id: Annotated[
+        str, typer.Option(
+            '--app-id', '-a',
+            help='The app id of the connection you wish to create. This value will be used to uniquely reference this connection when associating the connection with tools or agents'
+        )
+    ]
+):
+    add_connection(app_id=app_id)
+
+@connections_app.command(name="remove")
+def remove_connection_command(
+    app_id: Annotated[
+        str, typer.Option(
+            '--app-id', '-a',
+            help='The app id of the connection you wish to remove. This will also remove the configuration and credentials associated with the provided app id.'
+        )
+    ]
+):
+    remove_connection(app_id=app_id)
+
+@connections_app.command(name="list")
+def list_connections_command(
+    environment: Annotated[
+        ConnectionEnvironment, typer.Option(
+            '--environment', '--env',
+            help='Optionally limit the connections you want to see to only those of a certain environment'
+        )
+    ] = None,
+    verbose: Annotated[
+        bool, typer.Option(
+            '--verbose', '-v',
+            help='List the connections in json format without table styling'
+        )
+    ] = None
+):
+    list_connections(environment=environment, verbose=verbose)
+
+@connections_app.command(name="import")
+def import_connection_command(
+    file: Annotated[
+        str, typer.Option(
+            '--file', '-f',
+            help='Path to a spec file containing the connection details'
+        )
+    ]
+):
+    import_connection(file=file)
+
+@connections_app.command(name="configure")
+def configure_connection_command(
+    app_id: Annotated[
+        str, typer.Option(
+            '--app-id', '-a',
+            help='The app id you want to configure'
+        )
+    ],
+    environment: Annotated[
+        ConnectionEnvironment, typer.Option(
+            '--environment', '--env',
+            help='The environment you want to configure'
+        )
+    ],
+    type: Annotated[
+        ConnectionPreference, typer.Option(
+            '--type', '-t',
+            help='The type of credentials. `--type team` will mean the credentials apply to all users, `--type member` will mean each user will have to provide their own credentials'
+        )
+    ],
+    kind: Annotated[
+        ConnectionKind, typer.Option(
+            '--kind', '-k',
+            help='The kind of credentials the connection will use.'
+        )
+    ],
+    server_url: Annotated[
+        str, typer.Option(
+            '--server-url', '--url', '-u',
+            help='The url the connection is going to be used access.'
+        )
+    ] = None,
+    sso: Annotated[
+        bool, typer.Option(
+            '--sso', '-s',
+            help='Does the OAuth require a SAML provider. Only applicable to OAuth kinds'
+        )
+    ] = False,
+    idp_token_use: Annotated[
+        str, typer.Option(
+            '--idp-token-use',
+            help='The OAuth token use for the identity provider. Only applicable to OAuth kinds with sso'
+        )
+    ] = None,
+    idp_token_type: Annotated[
+        str, typer.Option(
+            '--idp-token-type',
+            help='The OAuth token type for the identity provider. Only applicable to OAuth kinds with sso'
+        )
+    ] = None,
+    idp_token_header: Annotated[
+        List[str], typer.Option(
+            '--idp-token-header',
+            help='Header values for the identity provider token request. Defaults to using `content-type: application/x-www-form-urlencoded`.  Multiple can be set using `--idp-token-header "content-type: application/x-www-form-urlencoded" --idp-token-header "encoding:..."` . Only applicable to OAuth kinds with sso'
+        )
+    ] = None,
+    app_token_header: Annotated[
+        List[str], typer.Option(
+            '--app-token-header',
+            help='Header values for the app token request. Defaults to using `content-type: application/x-www-form-urlencoded`.  Multiple can be set using `--app-token-header "content-type: application/x-www-form-urlencoded" --app-token-header "encoding:..."` . Only applicable to OAuth kinds with sso'
+        )
+    ] = None,
+    
+):
+    configure_connection(
+        app_id=app_id,
+        environment=environment,
+        type=type,
+        kind=kind,
+        server_url=server_url,
+        sso=sso,
+        idp_token_use=idp_token_use,
+        idp_token_type=idp_token_type,
+        idp_token_header=idp_token_header,
+        app_token_header=app_token_header
+    )
+
+@connections_app.command(name="set-credentials")
+def set_credentials_connection_command(
+
+   app_id: Annotated[
+        str, typer.Option(
+            '--app-id', '-a',
+            help='The app id you want to configure'
+        )
+    ],
+    environment: Annotated[
+        ConnectionEnvironment, typer.Option(
+            '--environment', '--env',
+            help='The environment you want to configure'
+        )
+    ],
+    username: Annotated[
+        str,
+        typer.Option(
+            '--username',
+            '-u',
+            help='For basic auth, the username to login with'
+        )
+    ] = None,
+    password: Annotated[
+        str,
+        typer.Option(
+            '--password',
+            '-p',
+            help='For basic auth, the password to login with'
+        )
+    ] = None,
+    token: Annotated[
+        str,
+        typer.Option(
+            '--token',
+            help='For bearer auth, the bearer token to use'
+        )
+    ] = None,
+    api_key: Annotated[
+        str,
+        typer.Option(
+            '--api-key',
+            '-k',
+            help='For api_key auth, the api key to use'
+        )
+    ] = None,
+    client_id: Annotated[
+        str,
+        typer.Option(
+            '--client-id',
+            # help='For oauth_auth_on_behalf_of_flow, oauth_auth_code_flow, oauth_auth_implicit_flow, oauth_auth_password_flow and oauth_auth_client_credentials_flow, the client_id to authenticate against the application token server'
+            help='For oauth_auth_on_behalf_of_flow, the client_id to authenticate against the application token server'
+        )
+    ] = None,
+    # client_secret: Annotated[
+    #     str,
+    #     typer.Option(
+    #         '--client-secret',
+    #         help='For oauth_auth_code_flow, oauth_auth_password_flow and oauth_auth_client_credentials_flow, the client_secret to authenticate with'
+    #     )
+    # ] = None,
+    token_url: Annotated[
+        str,
+        typer.Option(
+            '--token-url',
+            # help='For oauth_auth_on_behalf_of_flow, oauth_auth_code_flow, oauth_auth_password_flow and oauth_auth_client_credentials_flow, the url of the application token server'
+            help='For oauth_auth_on_behalf_of_flow, the url of the application token server'
+        )
+    ] = None,
+    # auth_url: Annotated[
+    #     str,
+    #     typer.Option(
+    #         '--auth-url',
+    #         help='For oauth_auth_code_flow, oauth_auth_implicit_flow and oauth_auth_password_flow, the url of the application token server'
+    #     )
+    # ] = None,
+    grant_type: Annotated[
+        str,
+        typer.Option(
+            '--grant-type',
+            help='For oauth_auth_on_behalf_of_flow, the grant type used by the application token server'
+        )
+    ] = None,
+    entries: Annotated[
+        List[str],
+        typer.Option(
+            '--entries', "-e",
+            help="For key_value, a key value pair in the form '<key>=<value>'. Multiple values can be passed using `-e key1=value1 -e key2=value2`"
+        )
+    ] = None,
+):
+    set_credentials_connection(
+        app_id=app_id,
+        environment=environment,
+        username=username,
+        password=password,
+        token=token,
+        api_key=api_key,
+        client_id=client_id,
+        # client_secret=client_secret,
+        token_url=token_url,
+        # auth_url=auth_url,
+        grant_type=grant_type,
+        entries=entries
+    )
+
+@connections_app.command(name="set-identity-provider")
+def set_identity_provider_connection_command(
+
+   app_id: Annotated[
+        str, typer.Option(
+            '--app-id', '-a',
+            help='The app id you want to configure'
+        )
+    ],
+    environment: Annotated[
+        ConnectionEnvironment, typer.Option(
+            '--environment', '--env',
+            help='The environment you want to configure'
+        )
+    ],
+    url: Annotated[
+        str, typer.Option(
+            '--url', '-u',
+            help='The token url of the identity provider'
+        )
+    ],
+    client_id: Annotated[
+        str,
+        typer.Option(
+            '--client-id',
+            help='The client_id to authenticate with the identity provider'
+        )
+    ],
+    client_secret: Annotated[
+        str,
+        typer.Option(
+            '--client-secret',
+            help='The client_secret to authenticate with the identity provider'
+        )
+    ],
+    scope: Annotated[
+        str,
+        typer.Option(
+            '--scope',
+            help='The scope of the identity provider'
+        )
+    ],
+    grant_type: Annotated[
+        str,
+        typer.Option(
+            '--grant-type',
+            help='The grant-type of the the identity provider'
+        )
+    ],
+):
+    set_identity_provider_connection(
+        app_id=app_id,
+        environment=environment,
+        url=url,
+        client_id=client_id,
+        client_secret=client_secret,
+        scope=scope,
+        grant_type=grant_type
+    )