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

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",

ibm_watsonx_orchestrate/cli/commands/tools/tools_controller.py

@@ -1,5 +1,4 @@
 import logging
-import asyncio
 import importlib
 import inspect
 import sys
@@ -11,29 +10,28 @@ import zipfile
 from enum import Enum
 from os import path
 from pathlib import Path
-from typing import Iterable, List
+from typing import Iterable, List, Any, Optional, cast
 import rich
 import json
-from rich.json import JSON
 import glob
 
 import rich.table
 import typer
 
-from rich.console import Console
 from rich.panel import Panel
 
-from ibm_watsonx_orchestrate.agent_builder.tools import BaseTool, ToolSpec
+from ibm_watsonx_orchestrate.agent_builder.tools import BaseTool, ToolSpec, ToolListEntry
 from ibm_watsonx_orchestrate.agent_builder.tools.flow_tool import create_flow_json_tool
-from ibm_watsonx_orchestrate.agent_builder.tools.langflow_tool import create_langflow_tool
+from ibm_watsonx_orchestrate.agent_builder.tools.langflow_tool import LangflowTool, create_langflow_tool
 from ibm_watsonx_orchestrate.agent_builder.tools.openapi_tool import create_openapi_json_tools_from_uri,create_openapi_json_tools_from_content
 from ibm_watsonx_orchestrate.cli.commands.models.models_controller import ModelHighlighter
 from ibm_watsonx_orchestrate.cli.commands.tools.types import RegistryType
 from ibm_watsonx_orchestrate.cli.commands.connections.connections_controller import configure_connection, remove_connection, add_connection
+from ibm_watsonx_orchestrate.cli.common import ListFormats, rich_table_to_markdown
 from ibm_watsonx_orchestrate.agent_builder.connections.types import  ConnectionType, ConnectionEnvironment, ConnectionPreference
 from ibm_watsonx_orchestrate.cli.config import Config, CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT, \
     PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_TYPE_OPT, PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT, \
-    DEFAULT_CONFIG_FILE_CONTENT
+    DEFAULT_CONFIG_FILE_CONTENT, PYTHON_REGISTRY_SKIP_VERSION_CHECK_OPT
 from ibm_watsonx_orchestrate.agent_builder.connections import ConnectionSecurityScheme, ExpectedCredentials
 from ibm_watsonx_orchestrate.flow_builder.flows.decorators import FlowWrapper
 from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
@@ -42,6 +40,7 @@ from ibm_watsonx_orchestrate.client.connections import get_connections_client, g
 from ibm_watsonx_orchestrate.client.utils import instantiate_client, is_local_dev
 from ibm_watsonx_orchestrate.flow_builder.utils import import_flow_support_tools
 from ibm_watsonx_orchestrate.utils.utils import sanitize_app_id
+from ibm_watsonx_orchestrate.utils.async_helpers import run_coroutine_sync
 from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 from ibm_watsonx_orchestrate.client.tools.tempus_client import TempusClient
 
@@ -56,6 +55,11 @@ DEFAULT_LANGFLOW_TOOL_REQUIREMENTS = [
     "lfx==0.1.8"
 ]
 
+DEFAULT_LANGFLOW_RUNNER_MODULES = [
+    "lfx",
+    "lfx-nightly"
+]
+
 class ToolKind(str, Enum):
     openapi = "openapi"
     python = "python"
@@ -615,7 +619,7 @@ def get_whl_in_registry(registry_url: str, version: str) -> str| None:
     return wheel_file
 
 class ToolsController:
-    def __init__(self, tool_kind: ToolKind = None, file: str = None, requirements_file: str = None):
+    def __init__(self, tool_kind: ToolKind = None, file: str = None, requirements_file: Optional[str] = None):
         self.client = None
         self.tool_kind = tool_kind
         self.file = file
@@ -651,14 +655,14 @@ class ToolsController:
                     app_id = app_id[0]
                     connection = connections_client.get_draft_by_app_id(app_id=app_id)
                     connection_id = connection.connection_id
-                tools = asyncio.run(import_openapi_tool(file=args["file"], connection_id=connection_id))
+                tools = run_coroutine_sync(import_openapi_tool(file=args["file"], connection_id=connection_id))
             case "flow":
-                tools = asyncio.run(import_flow_tool(file=args["file"]))
+                tools = run_coroutine_sync(import_flow_tool(file=args["file"]))
             case "skill":
                 tools = []
                 logger.warning("Skill Import not implemented yet")
             case "langflow":
-                tools = asyncio.run(import_langflow_tool(file=args["file"],app_id=args.get('app_id',None)))
+                tools = run_coroutine_sync(import_langflow_tool(file=args["file"],app_id=args.get('app_id',None)))
             case _:
                 raise BadRequest("Invalid kind selected")
 
@@ -669,14 +673,18 @@ class ToolsController:
             yield tool
 
 
-    def list_tools(self, verbose=False):
+    def list_tools(self, verbose=False, format: ListFormats| None = None) -> List[dict[str, Any]] | str | None:
+        if verbose and format:
+            logger.error("For tools list, `--verbose` and `--format` are mutually exclusive options")
+            sys.exit(1)
+
         response = self.get_client().get()
         tool_specs = []
         parse_errors = []
 
         for tool in response:
             try:
-                tool_specs.append(ToolSpec.model_validate(tool))
+                tool_specs.append(ToolSpec.model_validate(tool, context="list"))
             except Exception as e:
                 name = tool.get('name', None)
                 parse_errors.append([
@@ -693,12 +701,19 @@ class ToolsController:
                 tools_list.append(json.loads(tool.dumps_spec()))
 
             rich.print_json(json.dumps(tools_list, indent=4))
+            return tools_list
         else:
+            tool_details = []
+
+            connections_client = get_connections_client()
+            connections = connections_client.list()
+
+            connections_dict = {conn.connection_id: conn for conn in connections}
+
             table = rich.table.Table(show_header=True, header_style="bold white", show_lines=True)
             column_args = {
                 "Name": {"overflow": "fold"},
                 "Description": {},
-                "Permission": {}, 
                 "Type": {}, 
                 "Toolkit": {}, 
                 "App ID": {"overflow": "fold"}
@@ -706,11 +721,6 @@ class ToolsController:
             for column in column_args:
                 table.add_column(column,**column_args[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
 
@@ -768,22 +778,31 @@ class ToolsController:
                         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),
+                entry = ToolListEntry(
+                    name=tool.__tool_spec__.name,
+                    description=tool.__tool_spec__.description,
+                    type=tool_type,
+                    toolkit=toolkit_name,
+                    app_ids=app_ids
                 )
 
-            rich.print(table)
+                if format == ListFormats.JSON:
+                    tool_details.append(entry)
+                else:
+                    table.add_row(*entry.get_row_details())
+
+            match format:
+                case ListFormats.JSON:
+                    return tool_details
+                case ListFormats.Table:
+                    return rich_table_to_markdown(table)
+                case _:
+                    rich.print(table)
 
-            for error in parse_errors:
-                for l in error:
-                    logger.error(l)
+        for error in parse_errors:
+            for l in error:
+                logger.error(l)
 
     def get_all_tools(self) -> dict:
         return {entry["name"]: entry["id"] for entry in self.get_client().get()}
@@ -851,15 +870,18 @@ class ToolsController:
 
                         cfg = Config()
                         registry_type = cfg.read(PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_TYPE_OPT) or DEFAULT_CONFIG_FILE_CONTENT[PYTHON_REGISTRY_HEADER][PYTHON_REGISTRY_TYPE_OPT]
+                        skip_version_check = cfg.read(PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_SKIP_VERSION_CHECK_OPT) or DEFAULT_CONFIG_FILE_CONTENT[PYTHON_REGISTRY_HEADER][PYTHON_REGISTRY_SKIP_VERSION_CHECK_OPT]
 
                         version = __version__
                         if registry_type == RegistryType.LOCAL:
+                            logger.warning(f"Using a local registry which is for development purposes only")
                             requirements.append(f"/packages/ibm_watsonx_orchestrate-0.6.0-py3-none-any.whl\n")
                         elif registry_type == RegistryType.PYPI:
-                            wheel_file = get_whl_in_registry(registry_url='https://pypi.org/simple/ibm-watsonx-orchestrate', version=version)
-                            if not wheel_file:
-                                logger.error(f"Could not find ibm-watsonx-orchestrate@{version} on https://pypi.org/project/ibm-watsonx-orchestrate")
-                                exit(1)
+                            if not skip_version_check:
+                                wheel_file = get_whl_in_registry(registry_url='https://pypi.org/simple/ibm-watsonx-orchestrate', version=version)
+                                if not wheel_file:
+                                    logger.error(f"Could not find ibm-watsonx-orchestrate@{version} on https://pypi.org/project/ibm-watsonx-orchestrate")
+                                    exit(1)
                             requirements.append(f"ibm-watsonx-orchestrate=={version}\n")
                         elif registry_type == RegistryType.TESTPYPI:
                             override_version = cfg.get(PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT) or version
@@ -890,13 +912,34 @@ class ToolsController:
                         tool_path = Path(self.file)
                         zip_tool_artifacts.write(tool_path, arcname=f"{tool_path.stem}.json")
 
-                        requirements = DEFAULT_LANGFLOW_TOOL_REQUIREMENTS
+                        requirements = []
 
                         if self.requirements_file:
                             requirements_file_path = Path(self.requirements_file)
                             requirements.extend(
                                 get_requirement_lines(requirements_file=requirements_file_path, remove_trailing_newlines=False)
                             )
+
+                        langflowTool = cast(LangflowTool, tool)
+                        # if there are additional requriements from the langflow model, we should add it to the requirement set
+                        if langflowTool.requirements and len(langflowTool.requirements) > 0:
+                            requirements.extend(langflowTool.requirements)
+
+                        # now check if the requirements contain modules listed in DEFAULT_LANGFLOW_RUNNER_MODULES
+                        # if it is needed, we are assuming the user wants to override the default langflow module
+                        # with a specific version
+                        runner_overridden = False
+                        for r in requirements:
+                            # get the module name from the requirements
+                            module_name = r.strip().split('==')[0].split('=')[0].split('>=')[0].split('<=')[0].split('~=')[0].lower()
+                            if not module_name.startswith('#'):
+                                if module_name in DEFAULT_LANGFLOW_RUNNER_MODULES:
+                                    runner_overridden = True
+                        
+                        if not runner_overridden:
+                            # add the default runner to the top of requirement list
+                            requirements = DEFAULT_LANGFLOW_TOOL_REQUIREMENTS + list(requirements)
+
                         requirements_content = '\n'.join(requirements) + '\n'
                         zip_tool_artifacts.writestr("requirements.txt",requirements_content)  
                         zip_tool_artifacts.writestr("bundle-format", "2.0.0\n")

ibm_watsonx_orchestrate/cli/commands/voice_configurations/voice_configurations_controller.py

@@ -3,10 +3,12 @@ import sys
 import rich
 import yaml
 import logging
-from ibm_watsonx_orchestrate.agent_builder.voice_configurations import VoiceConfiguration
+from typing import Optional, List, Any
+from ibm_watsonx_orchestrate.agent_builder.voice_configurations import VoiceConfiguration, VoiceConfigurationListEntry
 from ibm_watsonx_orchestrate.client.utils import instantiate_client
 from ibm_watsonx_orchestrate.client.voice_configurations.voice_configurations_client import VoiceConfigurationsClient
 from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
+from ibm_watsonx_orchestrate.cli.common import ListFormats, rich_table_to_markdown
 
 logger = logging.getLogger(__name__)
 
@@ -69,12 +71,13 @@ class VoiceConfigurationsController:
       
     return configs[0]
 
-  def list_voice_configs(self, verbose: bool) -> None:
+  def list_voice_configs(self, verbose: bool, format: Optional[ListFormats]=None) -> List[dict[str | Any]] | List[VoiceConfigurationListEntry] | str | None:
     voice_configs = self.fetch_voice_configs()
 
     if verbose:
       json_configs = [json.loads(x.dumps_spec()) for x in voice_configs]
       rich.print_json(json.dumps(json_configs, indent=4))
+      return json_configs
     else:
       config_table = rich.table.Table(
         show_header=True, 
@@ -94,18 +97,27 @@ class VoiceConfigurationsController:
       for column in column_args:
         config_table.add_column(column, **column_args[column])
 
+      config_details = []
+
       for config in voice_configs:
-        attached_agents = [x.display_name or x.name or x.id for x in config.attached_agents]
-        config_table.add_row(
-          config.name,
-          config.voice_configuration_id,
-          config.speech_to_text.provider,
-          config.text_to_speech.provider,
-          ",".join(attached_agents)
+        attached_agents = [x.name or x.id for x in config.attached_agents]
+        entry = VoiceConfigurationListEntry(
+          name=config.name,
+          id=config.voice_configuration_id,
+          speech_to_text_provider=config.speech_to_text.provider,
+          text_to_speech_provider=config.text_to_speech.provider,
+          attached_agents=attached_agents
         )
+        config_details.append(entry)
+        config_table.add_row(*entry.get_row_details())
       
-      rich.print(config_table)
-
+      match format:
+        case ListFormats.JSON:
+          return config_details
+        case ListFormats.Table:
+          return rich_table_to_markdown(config_table)
+        case _:
+          rich.print(config_table)
 
   def create_voice_config(self, voice_config: VoiceConfiguration) -> str | None:
     client = self.get_voice_configurations_client()

ibm_watsonx_orchestrate/cli/common.py

@@ -0,0 +1,26 @@
+from enum import Enum
+from rich.table import Table
+
+class ListFormats(str, Enum):
+    Table = "table"
+    JSON = "json"
+
+    def __str__(self):
+        return self.value 
+
+    def __repr__(self):
+        return repr(self.value)
+
+def rich_table_to_markdown(table: Table) -> str:
+    headers = [column.header for column in table.columns]
+    cols = [[cell for cell in col.cells] for col in table.columns]
+    rows = list(map(list, zip(*cols)))
+
+    # Header row
+    md = "| " + " | ".join(headers) + " |\n"
+    # Separator row
+    md += "| " + " | ".join(["---"] * len(headers)) + " |\n"
+    # # Data rows
+    for row in rows:
+        md += "| " + " | ".join(row) + " |\n"
+    return md

ibm_watsonx_orchestrate/cli/config.py

@@ -22,6 +22,7 @@ AUTH_MCSP_TOKEN_OPT = "wxo_mcsp_token"
 AUTH_MCSP_TOKEN_EXPIRY_OPT = "wxo_mcsp_token_expiry"
 CONTEXT_ACTIVE_ENV_OPT = "active_environment"
 PYTHON_REGISTRY_TYPE_OPT = "type"
+PYTHON_REGISTRY_SKIP_VERSION_CHECK_OPT = "skip_version_check"
 PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT = "test_package_version_override"
 ENV_WXO_URL_OPT = "wxo_url"
 ENV_IAM_URL_OPT = "iam_url"
@@ -40,7 +41,8 @@ DEFAULT_CONFIG_FILE_CONTENT = {
     CONTEXT_SECTION_HEADER: {CONTEXT_ACTIVE_ENV_OPT: None},
     PYTHON_REGISTRY_HEADER: {
         PYTHON_REGISTRY_TYPE_OPT: str(RegistryType.PYPI),
-        PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT: None
+        PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT: None,
+        PYTHON_REGISTRY_SKIP_VERSION_CHECK_OPT: False
     },
     ENVIRONMENTS_SECTION_HEADER: {
         PROTECTED_ENV_NAME: {
@@ -85,7 +87,8 @@ def _check_if_auth_config_file(folder, file):
 
 def clear_protected_env_credentials_token():
     auth_cfg = Config(config_file_folder=AUTH_CONFIG_FILE_FOLDER, config_file=AUTH_CONFIG_FILE)
-    auth_cfg.delete(AUTH_SECTION_HEADER, PROTECTED_ENV_NAME, AUTH_MCSP_TOKEN_OPT)
+    if auth_cfg.exists(AUTH_SECTION_HEADER, PROTECTED_ENV_NAME, AUTH_MCSP_TOKEN_OPT):
+        auth_cfg.delete(AUTH_SECTION_HEADER, PROTECTED_ENV_NAME, AUTH_MCSP_TOKEN_OPT)
 
 
 class ConfigFileTypes(str, Enum):
@@ -230,3 +233,31 @@ class Config:
 
         with open(self.config_file_path, 'w') as conf_file:
             yaml.dump(deletion_data, conf_file, allow_unicode=True)
+
+    def exists(self, *args) -> bool:
+        """
+        Determines if an item of arbitrary depth exists in the config file.
+        Takes an arbitrary number of args. Uses the args in order
+        as keys to access deeper sections of the config and then deleting the last specified key.
+        """
+        if len(args) < 1:
+            raise BadRequest("Config.delete() requires at least one positional argument")
+
+        config_data = {}
+        try:
+            with open(self.config_file_path, 'r') as conf_file:
+                config_data = yaml_safe_load(conf_file) or {}
+        except FileNotFoundError:
+            pass
+
+        expression = "config_data"
+        for key in args:
+            temp = eval(expression)
+
+            if not isinstance(temp, dict) or key not in temp:
+                return False
+
+            else:
+                expression += f"['{key}']"
+
+        return True

ibm_watsonx_orchestrate/client/connections/connections_client.py

@@ -3,27 +3,14 @@ from typing import List
 from ibm_cloud_sdk_core.authenticators import MCSPAuthenticator
 from pydantic import BaseModel, ValidationError
 from typing import Optional
-from enum import Enum
 
 from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
-from ibm_watsonx_orchestrate.agent_builder.connections.types import ConnectionEnvironment, ConnectionPreference, ConnectionConfiguration, ConnectionAuthType, ConnectionSecurityScheme, IdpConfigData, AppConfigData, ConnectionType
+from ibm_watsonx_orchestrate.agent_builder.connections.types import ConnectionEnvironment, ConnectionPreference, ConnectionConfiguration, ConnectionAuthType, ConnectionSecurityScheme, IdpConfigData, AppConfigData, ConnectionType, FetchConfigAuthTypes
 from ibm_watsonx_orchestrate.client.utils import is_cpd_env, is_local_dev
 
 import logging
 logger = logging.getLogger(__name__)
 
-
-class FetchConfigAuthTypes(str, Enum):
-    BASIC_AUTH = ConnectionType.BASIC_AUTH.value
-    BEARER_TOKEN = ConnectionType.BEARER_TOKEN.value
-    API_KEY_AUTH = ConnectionType.API_KEY_AUTH.value
-    OAUTH2_AUTH_CODE = ConnectionType.OAUTH2_AUTH_CODE.value
-    OAUTH2_IMPLICIT = 'oauth2_implicit'
-    OAUTH2_PASSWORD = ConnectionType.OAUTH2_PASSWORD.value
-    OAUTH2_CLIENT_CREDS = ConnectionType.OAUTH2_CLIENT_CREDS.value
-    OAUTH_ON_BEHALF_OF_FLOW = ConnectionType.OAUTH_ON_BEHALF_OF_FLOW.value
-    KEY_VALUE = ConnectionType.KEY_VALUE.value
-
 class ListConfigsResponse(BaseModel):
     connection_id: str = None,
     app_id: str = None