ibm-watsonx-orchestrate 1.12.2__py3-none-any.whl → 1.13.0b1__py3-none-any.whl

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.")
 
@@ -550,7 +552,6 @@ def run_db_migration() -> None:
     migration_command = f'''
         APPLIED_MIGRATIONS_FILE="/var/lib/postgresql/applied_migrations/applied_migrations.txt"
         touch "$APPLIED_MIGRATIONS_FILE"
-
         for file in /docker-entrypoint-initdb.d/*.sql; do
             filename=$(basename "$file")
 
@@ -566,11 +567,42 @@ def run_db_migration() -> None:
                 fi
             fi
         done
+
+        # Create wxo_observability database if it doesn't exist
+        if psql -U {pg_user} -lqt | cut -d \\| -f 1 | grep -qw wxo_observability; then
+            echo 'Existing wxo_observability DB found'
+        else
+            echo 'Creating wxo_observability DB'
+            createdb -U "{pg_user}" -O "{pg_user}" wxo_observability;
+            psql -U {pg_user} -q -d postgres -c "GRANT CONNECT ON DATABASE wxo_observability TO {pg_user}";
+        fi
+
+        # Run observability-specific migrations
+        OBSERVABILITY_MIGRATIONS_FILE="/var/lib/postgresql/applied_migrations/observability_migrations.txt"
+        touch "$OBSERVABILITY_MIGRATIONS_FILE"
+
+        for file in /docker-entrypoint-initdb.d/observability/*.sql; do
+            if [ -f "$file" ]; then
+                filename=$(basename "$file")
+                
+                if grep -Fxq "$filename" "$OBSERVABILITY_MIGRATIONS_FILE"; then
+                    echo "Skipping already applied observability migration: $filename"
+                else
+                    echo "Applying observability migration: $filename"
+                    if psql -U {pg_user} -d wxo_observability -q -f "$file" > /dev/null 2>&1; then
+                        echo "$filename" >> "$OBSERVABILITY_MIGRATIONS_FILE"
+                    else
+                        echo "Error applying observability migration: $filename. Stopping migrations."
+                        exit 1
+                    fi
+                fi
+            fi
+        done
         '''
 
     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 +656,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",

ibm_watsonx_orchestrate/cli/commands/tools/tools_controller.py

@@ -1,5 +1,4 @@
 import logging
-import asyncio
 import importlib
 import inspect
 import sys
@@ -11,25 +10,24 @@ import zipfile
 from enum import Enum
 from os import path
 from pathlib import Path
-from typing import Iterable, List, cast
+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 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, \
@@ -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
 
@@ -620,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
@@ -656,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")
 
@@ -674,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([
@@ -698,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"}
@@ -711,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
 
@@ -773,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()}

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