ibm-watsonx-orchestrate 1.12.0b1__py3-none-any.whl → 1.13.0b0__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/models/models_controller.py

@@ -6,7 +6,7 @@ import yaml
 import importlib
 import inspect
 from pathlib import Path
-from typing import List
+from typing import List, Optional
 
 import requests
 import rich
@@ -16,10 +16,11 @@ from ibm_watsonx_orchestrate.client.model_policies.model_policies_client import
 from ibm_watsonx_orchestrate.agent_builder.model_policies.types import ModelPolicy, ModelPolicyInner, \
     ModelPolicyRetry, ModelPolicyStrategy, ModelPolicyStrategyMode, ModelPolicyTarget
 from ibm_watsonx_orchestrate.client.models.models_client import ModelsClient
-from ibm_watsonx_orchestrate.agent_builder.models.types import VirtualModel, ProviderConfig, ModelType, ANTHROPIC_DEFAULT_MAX_TOKENS
+from ibm_watsonx_orchestrate.agent_builder.models.types import VirtualModel, ProviderConfig, ModelType, ANTHROPIC_DEFAULT_MAX_TOKENS, ModelListEntry
 from ibm_watsonx_orchestrate.client.utils import instantiate_client, is_cpd_env
 from ibm_watsonx_orchestrate.client.connections import get_connection_id, ConnectionType
 from ibm_watsonx_orchestrate.utils.environment import EnvService
+from ibm_watsonx_orchestrate.cli.common import ListFormats, rich_table_to_markdown
 
 logger = logging.getLogger(__name__)
 
@@ -149,7 +150,7 @@ class ModelsController:
             self.model_policies_client = instantiate_client(ModelPoliciesClient)
         return self.model_policies_client
 
-    def list_models(self, print_raw: bool = False) -> None:
+    def list_models(self, print_raw: bool = False, format: Optional[ListFormats] = None) -> List[ModelListEntry] | str |None:
         models_client: ModelsClient = self.get_models_client()
         model_policies_client: ModelPoliciesClient = self.get_model_policies_client()
         global WATSONX_URL
@@ -224,6 +225,7 @@ class ModelsController:
 
                 console.print("[yellow]★[/yellow] [italic dim]indicates a supported and preferred model[/italic dim]\n[blue dim]✨️[/blue dim] [italic dim]indicates a model from a custom provider[/italic dim]" )
             else:
+                model_details = []
                 table = rich.table.Table(
                     show_header=True,
                     title="[bold]Available Models[/bold]",
@@ -234,15 +236,32 @@ class ModelsController:
                     table.add_column(col)
 
                 for model in (virtual_models + virtual_model_policies):
-                    table.add_row(f"✨️ {model.name}", model.description or 'No description provided.')
+                    entry = ModelListEntry(
+                        name=model.name,
+                        description=model.description,
+                        is_custom=True
+                    )
+                    model_details.append(entry)
+                    table.add_row(*entry.get_row_details())
 
                 for model in sorted_models:
-                    model_id = model.get("model_id", "N/A")
-                    short_desc = model.get("short_description", "No description provided.")
-                    marker = "★ " if any(pref in model_id.lower() for pref in preferred_list) else ""
-                    table.add_row(f"[yellow]{marker}[/yellow]watsonx/{model_id}", short_desc)
-            
-                rich.print(table)
+                    name = model.get("model_id", "N/A")
+                    entry = ModelListEntry(
+                        name=name,
+                        description=model.get("short_description"),
+                        is_custom=False,
+                        recommended=any(pref in name.lower() for pref in preferred_list)
+                    )
+                    model_details.append(entry)
+                    table.add_row(*entry.get_row_details())
+
+                match format:
+                    case ListFormats.JSON:
+                        return model_details
+                    case ListFormats.Table:
+                        return rich_table_to_markdown(table)
+                    case _: 
+                        rich.print(table)
 
     def import_model(self, file: str, app_id: str | None) -> List[VirtualModel]:
         from ibm_watsonx_orchestrate.cli.commands.models.model_provider_mapper import validate_ProviderConfig # lazily import this because the lut building is expensive

ibm_watsonx_orchestrate/cli/commands/partners/offering/partners_offering_controller.py

@@ -23,6 +23,7 @@ from ibm_watsonx_orchestrate.client.connections import get_connections_client
 from ibm_watsonx_orchestrate.agent_builder.connections.types import ConnectionEnvironment
 from ibm_watsonx_orchestrate.cli.commands.connections.connections_controller import export_connection
 from ibm_watsonx_orchestrate.cli.commands.tools.tools_controller import ToolsController
+from ibm_watsonx_orchestrate.utils.utils import sanitize_catalog_label
 from .types import *
 
 APPLICATIONS_FILE_VERSION = '1.16.0'
@@ -54,7 +55,7 @@ def get_tool_bindings(tool_names: list[str]) -> dict[str, dict]:
 
     return results
 
-def _patch_agent_yamls(project_root: Path, publisher_name: str):
+def _patch_agent_yamls(project_root: Path, publisher_name: str, parent_agent_name: str):
     agents_dir = project_root / "agents"
     if not agents_dir.exists():
         return
@@ -70,15 +71,18 @@ def _patch_agent_yamls(project_root: Path, publisher_name: str):
         if "language_support" not in agent_data:
             agent_data["language_support"] = ["English"]
         if "icon" not in agent_data:
-            agent_data["icon"] = "inline-svg-of-icon"
+            agent_data["icon"] = AGENT_CATALOG_ONLY_PLACEHOLDERS['icon']
         if "category" not in agent_data:
             agent_data["category"] = "agent"
         if "supported_apps" not in agent_data:
             agent_data["supported_apps"] = []
+        if "agent_role" not in agent_data:
+            agent_data["agent_role"] = "manager" if agent_data.get("name") == parent_agent_name else "collaborator"
 
         with open(agent_yaml, "w") as f:
             yaml.safe_dump(agent_data, f, sort_keys=False)
 
+
 def _create_applications_entry(connection_config: dict) -> dict:
     return {
         'app_id': connection_config.get('app_id'),
@@ -116,6 +120,15 @@ class PartnersOfferingController:
         sys.exit(1)
 
     def create(self, offering: str, publisher_name: str, agent_type: str, agent_name: str):
+
+        # Sanitize offering name
+        original_offering = offering
+        offering = sanitize_catalog_label(offering)
+
+        if offering != original_offering:
+            logger.warning("Offering name must contain only alpahnumeric characters or underscore")
+            logger.info(f"Offering '{original_offering}' has been updated to '{offering}'")
+
         # Create parent project folder
         project_root = self.root / offering
 
@@ -179,7 +192,7 @@ class PartnersOfferingController:
         output_zip.unlink(missing_ok=True)
 
         # Patch the agent yamls with publisher, tags, icon, etc.
-        _patch_agent_yamls(project_root, publisher_name)
+        _patch_agent_yamls(project_root=project_root, publisher_name=publisher_name, parent_agent_name=agent_name)
 
 
         # Create offering.yaml file -------------------------------------------------------
@@ -337,12 +350,16 @@ class PartnersOfferingController:
                             **agent_data
                         )
                         agent = Agent.model_validate(agent_details)
-                        AgentsController().persist_record(agent=agent)
                     case AgentKind.EXTERNAL:
                         agent_details = parse_create_external_args(
                             **agent_data
                         )
                         agent = ExternalAgent.model_validate(agent_details)
+                
+                # Placeholder detection
+                for label,placeholder in AGENT_CATALOG_ONLY_PLACEHOLDERS.items():
+                    if agent_data.get(label) == placeholder:
+                        logger.warning(f"Placeholder '{label}' detected for agent '{agent_name}', please ensure '{label}' is correct before packaging.")
 
                 agent_json_path = f"{top_level_folder}/agents/{agent_name}/config.json"
                 zf.writestr(agent_json_path, json.dumps(agent_data, indent=2))

ibm_watsonx_orchestrate/cli/commands/partners/offering/types.py

@@ -24,6 +24,10 @@ CATALOG_ONLY_FIELDS = [
     'supported_apps'
 ]
 
+AGENT_CATALOG_ONLY_PLACEHOLDERS = {
+    'icon': "inline-svg-of-icon",
+}
+
 class AgentKind(str, Enum):
     NATIVE = "native"
     EXTERNAL = "external"
@@ -87,21 +91,9 @@ class Offering(BaseModel):
         return values
     
     def validate_ready_for_packaging(self):
-        self.test_for_placeholder_values()
-    
-    def test_for_placeholder_values(self):
-        placholders = False
-        # part numbers
-        if not self.part_number:
-            raise ValueError(f"Offering '{self.name}' does not have valid part numbers")
-        
-        for (k,v) in self.part_number.model_dump().items():
-            if v == CATALOG_PLACEHOLDERS['part_number']:
-                logger.warning(f"Placeholder part number detected for platform '{k}', please ensure valid part numbers are entered before packaging.")
-                placholders = True
-        
-        if placholders:
-            raise ValueError(f"Offering '{self.name}' cannot be packaged with placeholder values")
+        # Leaving this fn here in case we want to reintroduce validation
+        pass
+
 
 
 

ibm_watsonx_orchestrate/cli/commands/server/server_command.py

@@ -16,7 +16,7 @@ from ibm_watsonx_orchestrate.client.utils import instantiate_client
 from ibm_watsonx_orchestrate.cli.commands.environment.environment_controller import _login
 
 from ibm_watsonx_orchestrate.cli.config import PROTECTED_ENV_NAME, clear_protected_env_credentials_token, Config, \
-    AUTH_CONFIG_FILE_FOLDER, AUTH_CONFIG_FILE, AUTH_MCSP_TOKEN_OPT, AUTH_SECTION_HEADER, USER_ENV_CACHE_HEADER, LICENSE_HEADER, \
+    AUTH_CONFIG_FILE_FOLDER, AUTH_CONFIG_FILE, AUTH_MCSP_TOKEN_OPT, AUTH_SECTION_HEADER, LICENSE_HEADER, \
     ENV_ACCEPT_LICENSE
 from ibm_watsonx_orchestrate.client.agents.agent_client import AgentClient
 from ibm_watsonx_orchestrate.utils.docker_utils import DockerLoginService, DockerComposeCore, DockerUtils
@@ -38,8 +38,12 @@ def refresh_local_credentials() -> None:
     """
     Refresh the local credentials
     """
-    clear_protected_env_credentials_token()
-    _login(name=PROTECTED_ENV_NAME, apikey=None)
+    try:
+        clear_protected_env_credentials_token()
+        _login(name=PROTECTED_ENV_NAME, apikey=None)
+
+    except:
+        logger.warning("Failed to refresh local credentials, please run `orchestrate env activate local`")
 
 def run_compose_lite(
         final_env_file: Path,
@@ -51,11 +55,11 @@ def run_compose_lite(
         with_connections_ui=False,
         with_langflow=False,
     ) -> None:
-    EnvService.prepare_clean_env(final_env_file)
-    db_tag = EnvService.read_env_file(final_env_file).get('DBTAG', None)
+    env_service.prepare_clean_env(final_env_file)
+    db_tag = env_service.read_env_file(final_env_file).get('DBTAG', None)
     logger.info(f"Detected architecture: {platform.machine()}, using DBTAG: {db_tag}")
 
-    compose_core = DockerComposeCore(env_service)
+    compose_core = DockerComposeCore(env_service=env_service)
 
     # Step 1: Start only the DB container
     result = compose_core.service_up(service_name="wxo-server-db", friendly_name="WxO Server DB", final_env_file=final_env_file, compose_env=os.environ)
@@ -197,7 +201,7 @@ def run_compose_lite_ui(user_env_file: Path) -> bool:
         logger.error("Healthcheck failed orchestrate server.  Make sure you start the server components with `orchestrate server start` before trying to start the chat UI")
         return False
 
-    compose_core = DockerComposeCore(env_service)
+    compose_core = DockerComposeCore(env_service=env_service)
 
     result = compose_core.service_up(service_name="ui", friendly_name="UI", final_env_file=final_env_file)
 
@@ -234,7 +238,7 @@ def run_compose_lite_down_ui(user_env_file: Path, is_reset: bool = False) -> Non
 
     cli_config = Config()
     env_service = EnvService(cli_config)
-    compose_core = DockerComposeCore(env_service)
+    compose_core = DockerComposeCore(env_service=env_service)
 
     result = compose_core.service_down(service_name="ui", friendly_name="UI", final_env_file=final_env_file, is_reset=is_reset)
 
@@ -255,7 +259,7 @@ def run_compose_lite_down(final_env_file: Path, is_reset: bool = False) -> None:
 
     cli_config = Config()
     env_service = EnvService(cli_config)
-    compose_core = DockerComposeCore(env_service)
+    compose_core = DockerComposeCore(env_service=env_service)
 
     result = compose_core.services_down(final_env_file=final_env_file, is_reset=is_reset)
 
@@ -276,7 +280,7 @@ def run_compose_lite_logs(final_env_file: Path) -> None:
 
     cli_config = Config()
     env_service = EnvService(cli_config)
-    compose_core = DockerComposeCore(env_service)
+    compose_core = DockerComposeCore(env_service=env_service)
 
     result = compose_core.services_logs(final_env_file=final_env_file, should_follow=True)
 
@@ -395,7 +399,8 @@ def server_start(
     env_service.set_compose_file_path_in_env(custom_compose_file)
 
     user_env = env_service.get_user_env(user_env_file=user_env_file, fallback_to_persisted_env=False)
-    env_service.persist_user_env(user_env, include_secrets=persist_env_secrets)
+    developer_edition_source = env_service.get_dev_edition_source_core(user_env)
+    env_service.persist_user_env(user_env, include_secrets=persist_env_secrets, source=developer_edition_source)
     
     merged_env_dict = env_service.prepare_server_env_vars(user_env=user_env, should_drop_auth_routes=False)
 
@@ -451,10 +456,7 @@ def server_start(
         )
         exit(1)
 
-    try:
-        refresh_local_credentials()
-    except:
-        logger.warning("Failed to refresh local credentials, please run `orchestrate env activate local`")
+    refresh_local_credentials()
 
     logger.info(f"You can run `orchestrate env activate local` to set your environment or `orchestrate chat start` to start the UI service and begin chatting.")
 
@@ -570,7 +572,7 @@ def run_db_migration() -> None:
 
     cli_config = Config()
     env_service = EnvService(cli_config)
-    compose_core = DockerComposeCore(env_service)
+    compose_core = DockerComposeCore(env_service=env_service)
 
     result = compose_core.service_container_bash_exec(service_name="wxo-server-db",
                                                       log_message="Running Database Migration...",
@@ -624,7 +626,7 @@ def create_langflow_db() -> None:
 
     cli_config = Config()
     env_service = EnvService(cli_config)
-    compose_core = DockerComposeCore(env_service)
+    compose_core = DockerComposeCore(env_service=env_service)
 
     result = compose_core.service_container_bash_exec(service_name="wxo-server-db",
                                                       log_message="Preparing Langflow resources...",

ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_controller.py

@@ -1,8 +1,8 @@
 import os
 import zipfile
 import tempfile
-from typing import List, Optional
-from enum import Enum
+from typing import List, Optional, Any
+from pydantic import BaseModel
 import logging
 import sys
 import re
@@ -10,7 +10,7 @@ import requests
 from ibm_watsonx_orchestrate.client.toolkit.toolkit_client import ToolKitClient
 from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
 from ibm_watsonx_orchestrate.agent_builder.toolkits.base_toolkit import BaseToolkit, ToolkitSpec
-from ibm_watsonx_orchestrate.agent_builder.toolkits.types import ToolkitKind, Language, ToolkitSource, ToolkitTransportKind
+from ibm_watsonx_orchestrate.agent_builder.toolkits.types import ToolkitKind, Language, ToolkitSource, ToolkitTransportKind, ToolkitListEntry
 from ibm_watsonx_orchestrate.client.utils import instantiate_client
 from ibm_watsonx_orchestrate.utils.utils import sanitize_app_id
 from ibm_watsonx_orchestrate.client.connections import get_connections_client
@@ -18,7 +18,7 @@ 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
+from ibm_watsonx_orchestrate.cli.common import ListFormats, rich_table_to_markdown
 from rich.json import JSON
 import rich
 import rich.table
@@ -264,8 +264,119 @@ class ToolkitController:
         except requests.HTTPError as e:
             logger.error(e.response.text)
             exit(1)
+    
+    def _lookup_toolkit_resource_value(
+            self,
+            toolkit: BaseToolkit, 
+            lookup_table: dict[str, str], 
+            target_attr: str,
+            target_attr_display_name: str
+        ) -> List[str] | str | None:
+        """
+        Using a lookup table convert all the strings in a given field of an agent into their equivalent in the lookup table
+        Example: lookup_table={1: obj1, 2: obj2} agent=Toolkit(tools=[1,2]) return. [obj1, obj2]
+
+        Args:
+            toolkit: A toolkit
+            lookup_table: A dictionary that maps one value to another
+            target_attr: The field to convert on the provided agent
+            target_attr_display_name: The name of the field to be displayed in the event of an error
+        """
+        attr_value = getattr(toolkit, target_attr, None)
+        if not attr_value:
+            return
+        
+        if isinstance(attr_value, list):
+            new_resource_list=[]
+            for value in attr_value:
+                if value in lookup_table:
+                    new_resource_list.append(lookup_table[value])
+                else:
+                    logger.warning(f"{target_attr_display_name} with ID '{value}' not found. Returning {target_attr_display_name} ID")
+                    new_resource_list.append(value)
+            return new_resource_list
+        else:
+            if attr_value in lookup_table:
+                return lookup_table[attr_value]
+            else:
+                logger.warning(f"{target_attr_display_name} with ID '{attr_value}' not found. Returning {target_attr_display_name} ID")
+                return attr_value
+
+    def _construct_lut_toolkit_resource(self, resource_list: List[dict], key_attr: str, value_attr) -> dict:
+        """
+            Given a list of dictionaries build a key -> value look up table
+            Example [{id: 1, name: obj1}, {id: 2, name: obj2}] return {1: obj1, 2: obj2}
+
+            Args:
+                resource_list: A list of dictionries from which to build the lookup table from
+                key_attr: The name of the field whose value will form the key of the lookup table
+                value_attrL The name of the field whose value will form the value of the lookup table
+
+            Returns:
+                A lookup table
+        """
+        lut = {}
+        for resource in resource_list:
+            if isinstance(resource, BaseModel):
+                resource = resource.model_dump()
+            lut[resource.get(key_attr, None)] = resource.get(value_attr, None)
+        return lut
+    
+    def _batch_request_resource(self, client_fn, ids, batch_size=50) -> List[dict]:
+        resources = []
+        for i in range(0, len(ids), batch_size):
+                chunk = ids[i:i + batch_size]
+                resources += (client_fn(chunk))
+        return resources
+
+    def _get_all_unique_toolkit_resources(self, toolkits: List[BaseToolkit], target_attr: str) -> List[str]:
+        """
+            Given a list of toolkits get all the unique values of a certain field
+            Example: tk1.tools = [1 ,2 ,3] and tk2.tools = [2, 4, 5] then return [1, 2, 3, 4, 5]
+            Example: tk1.id = "123" and tk2.id = "456" then return ["123", "456"]
+
+            Args:
+                toolkits: List of toolkits
+                target_attr: The name of the field to access and get unique elements
+
+            Returns:
+                A list of unique elements from across all toolkits
+        """
+        all_ids = set()
+        for toolkit in toolkits:
+            attr_value = getattr(toolkit, target_attr, None)
+            if attr_value:
+                if isinstance(attr_value, list):
+                    all_ids.update(attr_value)
+                else:
+                    all_ids.add(attr_value)
+        return list(all_ids)
+    
+    def _bulk_resolve_toolkit_tools(self, toolkits: List[BaseToolkit]) -> List[BaseToolkit]:
+        new_toolkit_specs = [tk.__toolkit_spec__ for tk in toolkits].copy()
+        all_tools_ids = self._get_all_unique_toolkit_resources(new_toolkit_specs, "tools")
+        if not all_tools_ids:
+            return toolkits
+        
+        tool_client = instantiate_client(ToolClient)
+        
+        all_tools = self._batch_request_resource(tool_client.get_drafts_by_ids, all_tools_ids)
+
+        tool_lut = self._construct_lut_toolkit_resource(all_tools, "id", "name")
+        
+        new_toolkits = []
+        for toolkit_spec in new_toolkit_specs:
+            tool_names = self._lookup_toolkit_resource_value(toolkit_spec, tool_lut, "tools", "Tool")
+            if tool_names:
+                toolkit_spec.tools = tool_names
+            new_toolkits.append(BaseToolkit(toolkit_spec))
+        return new_toolkits
+
+    def list_toolkits(self, verbose=False, format: ListFormats| None = None) -> List[dict[str, Any]] | List[ToolkitListEntry] | str | None:
+        if verbose and format:
+            logger.error("For toolkits list, `--verbose` and `--format` are mutually exclusive options")
+            sys.exit(1)
 
-    def list_toolkits(self, verbose=False):
         client = self.get_client()
         response = client.get()
         toolkit_spec = [ToolkitSpec.model_validate(toolkit) for toolkit in response]
@@ -276,7 +387,10 @@ class ToolkitController:
             for toolkit in toolkits:
                 tools_list.append(json.loads(toolkit.dumps_spec()))
             rich.print(JSON(json.dumps(tools_list, indent=4)))
+            return tools_list
         else:
+            toolkit_details = []
+
             table = rich.table.Table(show_header=True, header_style="bold white", show_lines=True)
             column_args = {
                 "Name": {"overflow": "fold"},
@@ -288,23 +402,14 @@ class ToolkitController:
             for column in column_args:
                 table.add_column(column,**column_args[column])
 
-            tools_client = instantiate_client(ToolClient)
-
             connections_client = get_connections_client()
             connections = connections_client.list()
 
             connections_dict = {conn.connection_id: conn for conn in connections}
 
-            for toolkit in toolkits:
-                tool_ids = toolkit.__toolkit_spec__.tools or []
-                tool_names = []
-                if len(tool_ids) == 0:
-                    logger.warning("This toolkit contains no tools.")
-
-                for tool_id in tool_ids:
-                    tool = tools_client.get_draft_by_id(tool_id)
-                    tool_names.append(tool["name"])
+            resolved_toolkits = self._bulk_resolve_toolkit_tools(toolkits)
 
+            for toolkit in resolved_toolkits:
                 app_ids = []
                 connection_ids = toolkit.__toolkit_spec__.mcp.connections.values()
 
@@ -317,15 +422,22 @@ class ToolkitController:
                     else:
                         app_id = ""
                     app_ids.append(app_id)
-
-
-
-                table.add_row(
-                    toolkit.__toolkit_spec__.name,
-                    "MCP",
-                    toolkit.__toolkit_spec__.description,
-                    ", ".join(tool_names),
-                    ", ".join(app_ids),
+                
+                entry = ToolkitListEntry(
+                    name = toolkit.__toolkit_spec__.name,
+                    description = toolkit.__toolkit_spec__.description,
+                    tools = toolkit.__toolkit_spec__.tools,
+                    app_ids = app_ids
                 )
-
-            rich.print(table)
+                if format == ListFormats.JSON:
+                    toolkit_details.append(entry)
+                else:
+                    table.add_row(*entry.get_row_details())
+
+            match format:
+                case ListFormats.JSON:
+                    return toolkit_details
+                case ListFormats.Table:
+                    return rich_table_to_markdown(table)
+                case _:
+                    rich.print(table)

ibm_watsonx_orchestrate/cli/commands/tools/tools_command.py

@@ -1,6 +1,6 @@
 import typer
 from typing import List
-from typing_extensions import Annotated
+from typing_extensions import Annotated, Optional
 from ibm_watsonx_orchestrate.cli.commands.tools.tools_controller import ToolsController, ToolKind
 tools_app= typer.Typer(no_args_is_help=True)
 
@@ -34,7 +34,7 @@ def tool_import(
         )
     ] = None,
     requirements_file: Annotated[
-        str,
+        Optional[str],
         typer.Option(
             "--requirements-file",
             "-r",