ibm-watsonx-orchestrate 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_controller.py

@@ -0,0 +1,212 @@
+import os
+import zipfile
+import tempfile
+from typing import List, Optional
+from enum import Enum
+import logging
+import sys
+import re
+import requests
+from ibm_watsonx_orchestrate.client.toolkit.toolkit_client import ToolKitClient
+from ibm_watsonx_orchestrate.client.utils import instantiate_client
+from ibm_watsonx_orchestrate.utils.utils import sanatize_app_id
+from ibm_watsonx_orchestrate.client.connections import get_connections_client
+import typer
+import json
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from ibm_watsonx_orchestrate.client.utils import is_local_dev
+
+logger = logging.getLogger(__name__)
+
+class ToolkitKind(str, Enum):
+    MCP = "mcp"
+
+def get_connection_id(app_id: str) -> str:
+    connections_client = get_connections_client()
+    existing_draft_configuration = connections_client.get_config(app_id=app_id, env='draft')
+    existing_live_configuration = connections_client.get_config(app_id=app_id, env='live')
+
+    for config in [existing_draft_configuration, existing_live_configuration]:
+        if config and config.security_scheme != 'key_value_creds':
+            logger.error("Only key_value credentials are currently supported")
+            exit(1)
+    connection_id = None
+    if app_id is not None:
+        connection = connections_client.get(app_id=app_id)
+        if  not connection:
+            logger.error(f"No connection exists with the app-id '{app_id}'")
+            exit(1)
+        connection_id = connection.connection_id
+    return connection_id
+
+def validate_params(kind: str):
+    if kind != ToolkitKind.MCP:
+        raise ValueError(f"Unsupported toolkit kind: {kind}")
+
+
+class ToolkitController:
+    def __init__(
+        self, 
+        kind: ToolkitKind = None,
+        name: str = None,
+        description: str = None,
+        package_root: str  = None,
+        command: str  = None,
+    ):
+        self.kind = kind
+        self.name = name
+        self.description = description
+        self.package_root = package_root
+        self.command = command
+        self.client = None
+
+    def get_client(self) -> ToolKitClient:
+        if not self.client:
+            self.client = instantiate_client(ToolKitClient)
+        return self.client
+
+    def import_toolkit(self, tools: Optional[List[str]] = None, app_id: Optional[List[str]] = None):
+        if not is_local_dev():
+            logger.error("This functionality is only available for Local Environments")
+            sys.exit(1)
+
+        if app_id and isinstance(app_id, str):
+            app_id = [app_id]
+        elif not app_id:
+            app_id = []
+
+        validate_params(kind=self.kind)
+
+        remapped_connections = self._remap_connections(app_id)
+
+        client = self.get_client()
+        draft_toolkits = client.get_draft_by_name(toolkit_name=self.name)
+        if len(draft_toolkits) > 0:
+            logger.error(f"Existing toolkit found with name '{self.name}'. Failed to create toolkit.")
+            sys.exit(1)
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Handle zip file or directory
+            if self.package_root.endswith(".zip") and os.path.isfile(self.package_root):
+                zip_file_path = self.package_root
+            else:
+                zip_file_path = os.path.join(tmpdir, os.path.basename(f"{self.package_root.rstrip(os.sep)}.zip"))
+                with zipfile.ZipFile(zip_file_path, "w", zipfile.ZIP_DEFLATED) as mcp_zip_tool_artifacts:
+                    self._populate_zip(self.package_root, mcp_zip_tool_artifacts)
+
+            try:
+                command_parts = json.loads(self.command)
+                if not isinstance(command_parts, list):
+                    raise ValueError("JSON command must be a list of strings")
+            except (json.JSONDecodeError, ValueError):
+                command_parts = self.command.split()
+
+            command = command_parts[0]
+            args = command_parts[1:]
+
+            console = Console()
+            # List tools if not provided
+            if tools is None:
+                with Progress(
+                    SpinnerColumn(spinner_name="dots"),
+                    TextColumn("[progress.description]{task.description}"),
+                    transient=True,
+                    console=console,
+                ) as progress:
+                    progress.add_task(description="No tools specified, retrieving all tools from provided MCP server", total=None)
+                    tools = self.get_client().list_tools(
+                    zip_file_path=zip_file_path,
+                    command=command,
+                    args=args,
+                )
+                # Normalize tools to a list of tool names
+                tools = [
+                    tool["name"] if isinstance(tool, dict) and "name" in tool else tool
+                    for tool in tools
+                ]
+
+
+                logger.info("✅ The following tools will be imported:")
+                for tool in tools:
+                    console.print(f"  • {tool}")
+
+
+            # Create toolkit metadata
+            payload = {
+                "name": self.name,
+                "description": self.description,
+                "mcp": {
+                    "source": "files",
+                    "command": command,
+                    "args": args,
+                    "tools": tools,
+                    "connections": remapped_connections,
+                }
+            }
+            toolkit = self.get_client().create_toolkit(payload)
+            toolkit_id = toolkit["id"]
+
+            console = Console()
+            # Upload zip file
+            with Progress(
+                SpinnerColumn(spinner_name="dots"),
+                TextColumn("[progress.description]{task.description}"),
+                transient=True,
+                console=console,
+            ) as progress:
+                progress.add_task(description="Uploading toolkit zip file...", total=None)
+                self.get_client().upload(toolkit_id=toolkit_id, zip_file_path=zip_file_path)
+            logger.info(f"Successfully imported tool kit {self.name}")
+
+    def _populate_zip(self, package_root: str, zipfile: zipfile.ZipFile) -> str:
+        for root, _, files in os.walk(package_root):
+            for file in files:
+                full_path = os.path.join(root, file)
+                relative_path = os.path.relpath(full_path, start=package_root)
+                zipfile.write(full_path, arcname=relative_path)
+        return zipfile
+
+    def _remap_connections(self, app_ids: List[str]):
+        app_id_dict = {}
+        for app_id in app_ids:        
+            split_pattern = re.compile(r"(?<!\\)=")
+            split_id = re.split(split_pattern, app_id)
+            split_id = [x.replace("\\=", "=") for x in split_id]
+            if len(split_id) == 2:
+                runtime_id, local_id = split_id
+            elif len(split_id) == 1:
+                runtime_id = split_id[0]
+                local_id = split_id[0]
+            else:
+                raise typer.BadParameter(f"The provided --app-id '{app_id}' is not valid. This is likely caused by having mutliple equal signs, please use '\\=' to represent a literal '=' character")
+
+            if not len(runtime_id.strip()) or not len(local_id.strip()):
+                raise typer.BadParameter(f"The provided --app-id '{app_id}' is not valid. --app-id cannot be empty or whitespace")
+
+            runtime_id = sanatize_app_id(runtime_id)
+            app_id_dict[runtime_id] = get_connection_id(local_id)
+
+        return app_id_dict
+
+    
+    def remove_toolkit(self, name: str):
+        if not is_local_dev():
+            logger.error("This functionality is only available for Local Environments")
+            sys.exit(1)
+        try:
+            client = self.get_client()
+            draft_toolkits = client.get_draft_by_name(toolkit_name=name)
+            if len(draft_toolkits) > 1:
+                logger.error(f"Multiple existing toolkits found with name '{name}'. Failed to remove toolkit")
+                sys.exit(1)
+            if len(draft_toolkits) > 0:
+                draft_toolkit = draft_toolkits[0]
+                toolkit_id = draft_toolkit.get("id")
+                self.get_client().delete(toolkit_id=toolkit_id)
+                logger.info(f"Successfully removed tool {name}")
+            else:
+                logger.warning(f"No toolkit named '{name}' found")
+        except requests.HTTPError as e:
+            logger.error(e.response.text)
+            exit(1)

ibm_watsonx_orchestrate/cli/commands/tools/tools_controller.py

@@ -27,8 +27,9 @@ from ibm_watsonx_orchestrate.cli.config import Config, CONTEXT_SECTION_HEADER, C
     DEFAULT_CONFIG_FILE_CONTENT
 from ibm_watsonx_orchestrate.agent_builder.connections import ConnectionSecurityScheme, ExpectedCredentials
 from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
+from ibm_watsonx_orchestrate.client.toolkit.toolkit_client import ToolKitClient
 from ibm_watsonx_orchestrate.client.connections import get_connections_client, get_connection_type
-from ibm_watsonx_orchestrate.client.utils import instantiate_client
+from ibm_watsonx_orchestrate.client.utils import instantiate_client, is_local_dev
 from ibm_watsonx_orchestrate.utils.utils import sanatize_app_id
 
 from  ibm_watsonx_orchestrate import __version__
@@ -41,19 +42,20 @@ __supported_characters_pattern = re.compile("^(\\w|_)+$")
 class ToolKind(str, Enum):
     openapi = "openapi"
     python = "python"
+    mcp = "mcp"
     # skill = "skill"
 
 def validate_app_ids(kind: ToolKind, **args) -> None:
     app_ids = args.get("app_id")
     if not app_ids:
         return
-    
+
     if kind == ToolKind.openapi:
         if app_ids and len(app_ids) > 1:
             raise typer.BadParameter(
                 "Kind 'openapi' can only take one app-id"
             )
-    
+
     connections_client = get_connections_client()
 
     imported_connections_list = connections_client.list()
@@ -113,7 +115,7 @@ def get_connection_id(app_id: str) -> str:
 
 def parse_python_app_ids(app_ids: List[str]) -> dict[str,str]:
     app_id_dict = {}
-    for app_id in app_ids:        
+    for app_id in app_ids:
         # Split on = but not on \=
         split_pattern = re.compile(r"(?<!\\)=")
         split_id = re.split(split_pattern, app_id)
@@ -137,7 +139,7 @@ def parse_python_app_ids(app_ids: List[str]) -> dict[str,str]:
 def validate_python_connections(tool: BaseTool):
     if not tool.expected_credentials:
         return
-    
+
     connections_client = get_connections_client()
     connections = tool.__tool_spec__.binding.python.connections
 
@@ -156,13 +158,13 @@ def validate_python_connections(tool: BaseTool):
             expected_tool_conn_types = expected_cred.type
         else:
             expected_tool_conn_types = [expected_cred.type]
-        
+
         sanatized_expected_tool_app_id = sanatize_app_id(expected_tool_app_id)
         if sanatized_expected_tool_app_id in existing_sanatized_expected_tool_app_ids:
             logger.error(f"Duplicate App ID found '{expected_tool_app_id}'. Multiple expected app ids in the tool '{tool.__tool_spec__.name}' collide after sanaitization to '{sanatized_expected_tool_app_id}'. Please rename the offending app id in your tool.")
             sys.exit(1)
         existing_sanatized_expected_tool_app_ids.add(sanatized_expected_tool_app_id)
-        
+
         if sanatized_expected_tool_app_id not in provided_connections:
             logger.error(f"The tool '{tool.__tool_spec__.name}' requires an app-id '{expected_tool_app_id}'. Please use the `--app-id` flag to provide the required app-id")
             validation_failed = True
@@ -171,7 +173,7 @@ def validate_python_connections(tool: BaseTool):
             continue
 
         connection_id = connections.get(sanatized_expected_tool_app_id)
-        
+
         imported_connection = imported_connections.get(connection_id)
         imported_connection_auth_type = get_connection_type(security_scheme=imported_connection.security_scheme, auth_type=imported_connection.auth_type)
 
@@ -182,7 +184,7 @@ def validate_python_connections(tool: BaseTool):
         if imported_connection and len(expected_tool_conn_types) and imported_connection_auth_type not in expected_tool_conn_types:
             logger.error(f"The app-id '{imported_connection.app_id}' is of type '{imported_connection_auth_type.value}'. The tool '{tool.__tool_spec__.name}' accepts connections of the following types '{', '.join(expected_tool_conn_types)}'. Use `orchestrate connections list` to view current connections and use `orchestrate connections add` to create the relevent connection")
             validation_failed = True
-        
+
     if validation_failed:
         exit(1)
 
@@ -309,7 +311,7 @@ def import_python_tool(file: str, requirements_file: str = None, app_id: List[st
 
         validate_python_connections(obj)
         tools.append(obj)
-    
+
     return tools
 
 async def import_openapi_tool(file: str, connection_id: str) -> List[BaseTool]:
@@ -333,7 +335,7 @@ class ToolsController:
         # Ensure app_id is a list
         if args.get("app_id") and isinstance(args.get("app_id"), str):
             args["app_id"] = [args.get("app_id")]
-    
+
         validate_params(kind=kind, **args)
 
         match kind:
@@ -368,24 +370,27 @@ class ToolsController:
         response = self.get_client().get()
         tool_specs = [ToolSpec.model_validate(tool) for tool in response]
         tools = [BaseTool(spec=spec) for spec in tool_specs]
-        
 
         if verbose:
             tools_list = []
             for tool in tools:
-
                 tools_list.append(json.loads(tool.dumps_spec()))
 
             rich.print(JSON(json.dumps(tools_list, indent=4)))
         else:
             table = rich.table.Table(show_header=True, header_style="bold white", show_lines=True)
-            columns = ["Name", "Description", "Permission", "Type", "App ID"]
+            columns = ["Name", "Description", "Permission", "Type", "Toolkit", "App ID"]
             for column in columns:
                 table.add_column(column)
-            
+
+            connections_client = get_connections_client()
+            connections = connections_client.list()
+
+            connections_dict = {conn.connection_id: conn for conn in connections}
+
             for tool in tools:
                 tool_binding = tool.__tool_spec__.binding
-                
+
                 connection_ids = []
 
                 if tool_binding is not None:
@@ -394,25 +399,48 @@ class ToolsController:
                     elif tool_binding.python is not None and hasattr(tool_binding.python, "connections") and tool_binding.python.connections is not None:
                         for conn in tool_binding.python.connections:
                             connection_ids.append(tool_binding.python.connections[conn])
-                
-                connections_client = get_connections_client()
+                    elif tool_binding.mcp is not None and hasattr(tool_binding.mcp, "connections"):
+                        for conn in tool_binding.mcp.connections:
+                            connection_ids.append(tool_binding.mcp.connections[conn])
+
                 app_ids = []
                 for connection_id in connection_ids:
-                    app_id = str(connections_client.get_draft_by_id(connection_id))
+                    connection = connections_dict.get(connection_id)
+                    if connection:
+                        app_id = str(connection.app_id or connection.connection_id)
+                    elif connection_id:
+                        app_id = str(connection_id)
+                    else:
+                        app_id = ""
                     app_ids.append(app_id)
 
                 if tool_binding.python is not None:
                         tool_type=ToolKind.python
                 elif tool_binding.openapi is not None:
                         tool_type=ToolKind.openapi
+                elif tool_binding.mcp is not None:
+                        tool_type=ToolKind.mcp
                 else:
                         tool_type="Unknown"
                 
+                toolkit_name = ""
+
+                if is_local_dev():
+                    toolkit_client = instantiate_client(ToolKitClient)
+                    if tool.__tool_spec__.toolkit_id:
+                        toolkit = toolkit_client.get_draft_by_id(tool.__tool_spec__.toolkit_id)
+                        if isinstance(toolkit, dict) and "name" in toolkit:
+                            toolkit_name = toolkit["name"]
+                        elif toolkit:
+                            toolkit_name = str(toolkit)
+
+                
                 table.add_row(
                     tool.__tool_spec__.name,
                     tool.__tool_spec__.description,
                     tool.__tool_spec__.permission,
                     tool_type,
+                    toolkit_name,
                     ", ".join(app_ids),
                 )
 
@@ -434,7 +462,7 @@ class ToolsController:
                 if len(existing_tools) > 1:
                     logger.error(f"Multiple existing tools found with name '{tool.__tool_spec__.name}'. Failed to update tool")
                     sys.exit(1)
-                
+
                 if len(existing_tools) > 0:
                     existing_tool = existing_tools[0]
                     exist = True
@@ -540,7 +568,7 @@ class ToolsController:
             self.get_client().upload_tools_artifact(tool_id=tool_id, file_path=tool_artifact)
 
         logger.info(f"Tool '{tool.__tool_spec__.name}' updated successfully")
-    
+
     def remove_tool(self, name: str):
         try:
             client = self.get_client()

ibm_watsonx_orchestrate/cli/init_helper.py

@@ -0,0 +1,43 @@
+import importlib.metadata
+from importlib import resources
+from typing import Optional
+from rich import print as pprint
+from dotenv import dotenv_values
+import typer
+
+from ibm_watsonx_orchestrate.cli.config import Config, PYTHON_REGISTRY_HEADER, \
+    PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT
+
+
+def version_callback(checkVersion: bool=True):
+    if checkVersion:
+        __version__ = importlib.metadata.version('ibm-watsonx-orchestrate')
+        default_env = dotenv_values(resources.files("ibm_watsonx_orchestrate.docker").joinpath("default.env"))
+        cfg = Config()
+        pypi_override = cfg.read(PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT)
+
+        adk_version_str = f"[bold]ADK Version[/bold]: {__version__}"
+        if pypi_override is not None:
+            adk_version_str += f" [red bold](override: {pypi_override})[/red bold]"
+        pprint(adk_version_str)
+
+
+        pprint("[bold]Developer Edition Image Tags[/bold] [italic](if not overridden in env file)[/italic]")
+        for key, value in default_env.items():
+            if key.endswith('_TAG') or key == 'DBTAG':
+                pprint(f"  [bold]{key}[/bold]: {value}")
+
+        raise typer.Exit()
+
+    
+
+def init_callback(
+    ctx: typer.Context,
+    version: Optional[bool] = typer.Option(
+      None, 
+      "--version",
+      help="Show the installed version of the ADK and Developer Edition Tags",
+      callback=version_callback
+    )
+):
+    pass

ibm_watsonx_orchestrate/cli/main.py

@@ -11,19 +11,23 @@ from ibm_watsonx_orchestrate.cli.commands.models.models_command import models_ap
 from ibm_watsonx_orchestrate.cli.commands.environment.environment_command import environment_app
 from ibm_watsonx_orchestrate.cli.commands.channels.channels_command import channel_app
 from ibm_watsonx_orchestrate.cli.commands.knowledge_bases.knowledge_bases_command import knowledge_bases_app
+from ibm_watsonx_orchestrate.cli.commands.toolkit.toolkit_command import toolkits_app
+from ibm_watsonx_orchestrate.cli.init_helper import init_callback
 
 app = typer.Typer(
     no_args_is_help=True,
-    pretty_exceptions_enable=False
+    pretty_exceptions_enable=False,
+    callback=init_callback
 )
 app.add_typer(login_app)
 app.add_typer(environment_app, name="env", help='Add, remove, or select the activate env other commands will interact with (either your local server or a production instance)')
 app.add_typer(agents_app, name="agents", help='Interact with the agents in your active env')
 app.add_typer(tools_app, name="tools", help='Interact with the tools in your active env')
+app.add_typer(toolkits_app, name="toolkits", help="Interact with the toolkits in your active env")
 app.add_typer(knowledge_bases_app, name="knowledge-bases", help="Upload knowledge your agents can search through to your active env")
 app.add_typer(connections_app, name="connections", help='Interact with the agents in your active env')
-app.add_typer(server_app, name="server", help='Manipulate your local Orchestrate Developer Edition server [requires an Entitlement]')
-app.add_typer(chat_app, name="chat", help='Launch the chat ui for your local Developer Edition server [requires docker pull credentials]')
+app.add_typer(server_app, name="server", help='Manipulate your local Orchestrate Developer Edition server [requires entitlement]')
+app.add_typer(chat_app, name="chat", help='Launch the chat ui for your local Developer Edition server [requires entitlement]')
 app.add_typer(models_app, name="models", help='List the available large language models (llms) that can be used in your agent definitions')
 app.add_typer(channel_app, name="channels", help="Configure channels where your agent can exist on (such as embedded webchat)")
 app.add_typer(settings_app, name="settings", help='Configure the settings for your active env')

ibm_watsonx_orchestrate/client/connections/connections_client.py

@@ -51,7 +51,7 @@ class ConnectionsClient(BaseAPIClient):
     # DELETE api/v1/connections/applications/{app_id}
     def delete(self, app_id: str) -> dict:
         return self._delete(f"/connections/applications/{app_id}")
-    
+
     # GET /api/v1/connections/applications/{app_id}
     def get(self, app_id: str) -> GetConnectionResponse:
         try:
@@ -60,7 +60,7 @@ class ConnectionsClient(BaseAPIClient):
             if e.response.status_code == 404:
                 return None
             raise e
-    
+
 
     # GET api/v1/connections/applications
     def list(self) -> List[ListConfigsResponse]:
@@ -75,15 +75,15 @@ class ConnectionsClient(BaseAPIClient):
                 return []
             raise e
 
-    
+
     # POST /api/v1/connections/applications/{app_id}/configurations
     def create_config(self, app_id: str, payload: dict) -> None:
         self._post(f"/connections/applications/{app_id}/configurations", data=payload)
-    
+
     # PATCH /api/v1/connections/applications/{app_id}/configurations/{env}
     def update_config(self, app_id: str, env: ConnectionEnvironment, payload: dict) -> None:
         self._patch(f"/connections/applications/{app_id}/configurations/{env}", data=payload)
-    
+
     # `GET /api/v1/connections/applications/{app_id}/configurations/{env}'
     def get_config(self, app_id: str, env: ConnectionEnvironment) -> GetConfigResponse:
         try:
@@ -93,7 +93,7 @@ class ConnectionsClient(BaseAPIClient):
             if e.response.status_code == 404:
                 return None
             raise e
-    
+
     # POST /api/v1/connections/applications/{app_id}/configs/{env}/credentials
     # POST /api/v1/connections/applications/{app_id}/configs/{env}/runtime_credentials
     def create_credentials(self, app_id: str, env: ConnectionEnvironment, payload: dict, use_sso: bool) -> None:
@@ -101,7 +101,7 @@ class ConnectionsClient(BaseAPIClient):
             self._post(f"/connections/applications/{app_id}/configs/{env}/credentials", data=payload)
         else:
             self._post(f"/connections/applications/{app_id}/configs/{env}/runtime_credentials", data=payload)
-    
+
     # PATCH /api/v1/connections/applications/{app_id}/configs/{env}/credentials
     # PATCH /api/v1/connections/applications/{app_id}/configs/{env}/runtime_credentials
     def update_credentials(self, app_id: str, env: ConnectionEnvironment, payload: dict, use_sso: bool) -> None:
@@ -109,7 +109,7 @@ class ConnectionsClient(BaseAPIClient):
             self._patch(f"/connections/applications/{app_id}/configs/{env}/credentials", data=payload)
         else:
             self._patch(f"/connections/applications/{app_id}/configs/{env}/runtime_credentials", data=payload)
-    
+
     # GET /api/v1/connections/applications/{app_id}/configs/credentials?env={env}
     # GET /api/v1/connections/applications/{app_id}/configs/runtime_credentials?env={env}
     def get_credentials(self, app_id: str, env: ConnectionEnvironment, use_sso: bool) -> dict:
@@ -122,7 +122,7 @@ class ConnectionsClient(BaseAPIClient):
             if e.response.status_code == 404:
                 return None
             raise e
-    
+
     # DELETE /api/v1/connections/applications/{app_id}/configs/{env}/credentials
     # DELETE /api/v1/connections/applications/{app_id}/configs/{env}/runtime_credentials
     def delete_credentials(self, app_id: str, env: ConnectionEnvironment, use_sso: bool) -> None:
@@ -130,7 +130,7 @@ class ConnectionsClient(BaseAPIClient):
             self._delete(f"/connections/applications/{app_id}/configs/{env}/credentials")
         else:
             self._delete(f"/connections/applications/{app_id}/configs/{env}/runtime_credentials")
-    
+
     def get_draft_by_app_id(self, app_id: str) -> GetConnectionResponse:
         return self.get(app_id=app_id)
 
@@ -141,7 +141,7 @@ class ConnectionsClient(BaseAPIClient):
             if connection:
                 connections += connection
         return connections
-    
+
     def get_draft_by_id(self, conn_id) -> str:
         """Retrieve the app ID for a given connection ID."""
         if conn_id is None:
@@ -151,12 +151,12 @@ class ConnectionsClient(BaseAPIClient):
         except ClientAPIException as e:
             if e.response.status_code == 404:
                 logger.warning(f"Connections not found. Returning connection ID: {conn_id}")
-                return conn_id 
+                return conn_id
             raise
 
         app_id = next((conn.app_id for conn in connections if conn.connection_id == conn_id), None)
 
         if app_id is None:
             logger.warning(f"Connection with ID {conn_id} not found. Returning connection ID.")
-            return conn_id  
+            return conn_id
         return app_id

ibm_watsonx_orchestrate/client/toolkit/toolkit_client.py

@@ -0,0 +1,81 @@
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
+from typing_extensions import List
+import os
+import json
+
+class ToolKitClient(BaseAPIClient):
+    # POST /toolkits/prepare/list-tools
+    def list_tools(self, zip_file_path: str, command: str, args: List[str]) -> List[str]:
+        """
+        List the available tools inside the MCP server
+        """
+
+        filename = os.path.basename(zip_file_path)
+
+        list_toolkit_obj = {
+            "source": "files",
+            "command": command,
+            "args": args,
+        }
+
+        with open(zip_file_path, "rb") as f:
+            files = {
+                "list_toolkit_obj": (None, json.dumps(list_toolkit_obj), "application/json"),
+                "file": (filename, f, "application/zip"),
+            }
+
+            response = self._post("/orchestrate/toolkits/prepare/list-tools", files=files)
+
+        return response.get("tools", [])
+
+
+    # POST /api/v1/orchestrate/toolkits
+    def create_toolkit(self, payload) -> dict:
+        """
+        Creates new toolkit metadata
+        """
+        try:
+            return self._post("/orchestrate/toolkits", data=payload)
+        except ClientAPIException as e:
+            if e.response.status_code == 400 and "already exists" in e.response.text:
+                raise ClientAPIException(
+                    status_code=400,
+                    message=f"There is already a Toolkit with the same name that exists for this tenant."
+                )
+            raise(e)
+    
+    # POST /toolkits/{toolkit-id}/upload
+    def upload(self, toolkit_id: str, zip_file_path: str) -> dict:
+        """
+        Upload zip file to the toolkit.
+        """
+        filename = os.path.basename(zip_file_path)
+        with open(zip_file_path, "rb") as f:
+            files = {
+                "file": (filename, f, "application/zip", {"Expires": "0"})
+            }
+            return self._post(f"/orchestrate/toolkits/{toolkit_id}/upload", files=files)
+        
+    # DELETE /toolkits/{toolkit-id} 
+    def delete(self, toolkit_id: str) -> dict:
+        return self._delete(f"/orchestrate/toolkits/{toolkit_id}")
+
+    def get_draft_by_name(self, toolkit_name: str) -> List[dict]:
+        return self.get_drafts_by_names([toolkit_name])
+
+    def get_drafts_by_names(self, toolkit_names: List[str]) -> List[dict]:
+        formatted_toolkit_names = [f"names={x}" for x in toolkit_names]
+        return self._get(f"/orchestrate/toolkits?{'&'.join(formatted_toolkit_names)}")
+    
+    def get_draft_by_id(self, toolkit_id: str) -> dict:
+        if toolkit_id is None:
+            return ""
+        else:
+            try:
+                toolkit = self._get(f"/orchestrate/toolkits/{toolkit_id}")
+                return toolkit
+            except ClientAPIException as e:
+                if e.response.status_code == 404 and "not found with the given name" in e.response.text:
+                    return ""
+                raise(e)
+

ibm_watsonx_orchestrate/docker/compose-lite.yml

@@ -595,3 +595,4 @@ volumes:
 networks:
   default:
     name: wxo-server
+