ibm-watsonx-orchestrate 1.9.0b1__py3-none-any.whl → 1.10.0b0__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/copilot/copilot_controller.py

@@ -10,10 +10,12 @@ from rich.progress import Progress, SpinnerColumn, TextColumn
 from requests import ConnectionError
 from typing import List
 from ibm_watsonx_orchestrate.client.base_api_client import ClientAPIException
+from ibm_watsonx_orchestrate.agent_builder.knowledge_bases.types import KnowledgeBaseSpec
 from ibm_watsonx_orchestrate.agent_builder.tools import ToolSpec, ToolPermission, ToolRequestBody, ToolResponseBody
 from ibm_watsonx_orchestrate.cli.commands.agents.agents_controller import AgentsController, AgentKind, SpecVersion
 from ibm_watsonx_orchestrate.agent_builder.agents.types import DEFAULT_LLM, BaseAgentSpec
 from ibm_watsonx_orchestrate.client.agents.agent_client import AgentClient
+from ibm_watsonx_orchestrate.client.knowledge_bases.knowledge_base_client import KnowledgeBaseClient
 from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
 from ibm_watsonx_orchestrate.client.copilot.cpe.copilot_cpe_client import CPEClient
 from ibm_watsonx_orchestrate.client.utils import instantiate_client
@@ -56,10 +58,16 @@ def _get_incomplete_tool_from_name(tool_name: str) -> dict:
                        "input_schema": input_schema, "output_schema": output_schema})
     return spec.model_dump()
 
+
 def _get_incomplete_agent_from_name(agent_name: str) -> dict:
     spec = BaseAgentSpec(**{"name": agent_name, "description": agent_name, "kind": AgentKind.NATIVE})
     return spec.model_dump()
 
+def _get_incomplete_knowledge_base_from_name(kb_name: str) -> dict:
+    spec = KnowledgeBaseSpec(**{"name": kb_name, "description": kb_name})
+    return spec.model_dump()
+
+
 def _get_tools_from_names(tool_names: List[str]) -> List[dict]:
     if not len(tool_names):
         return []
@@ -115,6 +123,34 @@ def _get_agents_from_names(collaborators_names: List[str]) -> List[dict]:
 
     return agents
 
+def _get_knowledge_bases_from_names(kb_names: List[str]) -> List[dict]:
+    if not len(kb_names):
+        return []
+
+    kb_client = get_knowledge_bases_client()
+
+    try:
+        with _get_progress_spinner() as progress:
+            task = progress.add_task(description="Fetching Knowledge Bases", total=None)
+            knowledge_bases = kb_client.get_by_names(kb_names)
+            found_kbs = {kb.get("name") for kb in knowledge_bases}
+            progress.remove_task(task)
+            progress.refresh()
+            for kb_name in kb_names:
+                if kb_name not in found_kbs:
+                    logger.warning(
+                        f"Failed to find knowledge base named '{kb_name}'. Falling back to incomplete knowledge base definition. Copilot performance maybe effected.")
+                    knowledge_bases.append(_get_incomplete_knowledge_base_from_name(kb_name))
+    except ConnectionError:
+        logger.warning(
+            f"Failed to fetch knowledge bases from server. For optimal results please start the server and import the relevant knowledge bases {', '.join(kb_names)}.")
+        knowledge_bases = []
+        for kb_name in kb_names:
+            knowledge_bases.append(_get_incomplete_knowledge_base_from_name(kb_name))
+
+    return knowledge_bases
+
+
 def get_cpe_client() -> CPEClient:
     url = os.getenv('CPE_URL', "http://localhost:8081")
     return instantiate_client(client=CPEClient, url=url)
@@ -124,6 +160,10 @@ def get_tool_client(*args, **kwargs):
     return instantiate_client(ToolClient)
 
 
+def get_knowledge_bases_client(*args, **kwargs):
+    return instantiate_client(KnowledgeBaseClient)
+
+
 def get_native_client(*args, **kwargs):
     return instantiate_client(AgentClient)
 
@@ -144,18 +184,34 @@ def gather_utterances(max: int) -> list[str]:
     return utterances
 
 
-def get_deployed_tools_agents():
+def get_knowledge_bases(client):
+    with _get_progress_spinner() as progress:
+        task = progress.add_task(description="Fetching Knowledge Bases", total=None)
+        try:
+            knowledge_bases = client.get()
+            progress.remove_task(task)
+        except ConnectionError:
+            knowledge_bases = []
+            progress.remove_task(task)
+            progress.refresh()
+            logger.warning("Failed to contact wxo server to fetch knowledge_bases. Proceeding with empty agent list")
+    return knowledge_bases
+
+
+def get_deployed_tools_agents_and_knowledge_bases():
     all_tools = find_tools_by_description(tool_client=get_tool_client(), description=None)
     # TODO: this brings only the "native" agents. Can external and assistant agents also be collaborators?
     all_agents = find_agents(agent_client=get_native_client())
-    return {"tools": all_tools, "agents": all_agents}
+    all_knowledge_bases = get_knowledge_bases(get_knowledge_bases_client())
+
+    return {"tools": all_tools, "collaborators": all_agents, "knowledge_bases": all_knowledge_bases}
 
 
 def pre_cpe_step(cpe_client):
-    tools_agents = get_deployed_tools_agents()
+    tools_agents_and_knowledge_bases = get_deployed_tools_agents_and_knowledge_bases()
     user_message = ""
     with _get_progress_spinner() as progress:
-        task = progress.add_task(description="Initilizing Prompt Engine", total=None)
+        task = progress.add_task(description="Initializing Prompt Engine", total=None)
         response = cpe_client.submit_pre_cpe_chat(user_message=user_message)
         progress.remove_task(task)
 
@@ -165,15 +221,26 @@ def pre_cpe_step(cpe_client):
             rich.print('\n🤖 Copilot: ' + response["message"])
             user_message = Prompt.ask("\n👤 You").strip()
             message_content = {"user_message": user_message}
-        elif "description" in response and response["description"]:
+        elif "description" in response and response["description"]:  # after we have a description, we pass the all tools
             res["description"] = response["description"]
-            message_content = tools_agents
-        elif "metadata" in response:
-            res["agent_name"] = response["metadata"]["agent_name"]
-            res["agent_style"] = response["metadata"]["style"]
-            res["tools"] = [t for t in tools_agents["tools"] if t["name"] in response["metadata"]["tools"]]
-            res["collaborators"] = [a for a in tools_agents["agents"] if
-                                    a["name"] in response["metadata"]["collaborators"]]
+            message_content = {"tools": tools_agents_and_knowledge_bases['tools']}
+        elif "tools" in response and response[
+            'tools'] is not None:  # after tools were selected, we pass all collaborators
+            res["tools"] = [t for t in tools_agents_and_knowledge_bases["tools"] if
+                            t["name"] in response["tools"]]
+            message_content = {"collaborators": tools_agents_and_knowledge_bases['collaborators']}
+        elif "collaborators" in response and response[
+            'collaborators'] is not None:  # after we have collaborators, we pass all knowledge bases
+            res["collaborators"] = [a for a in tools_agents_and_knowledge_bases["collaborators"] if
+                                    a["name"] in response["collaborators"]]
+            message_content = {"knowledge_bases": tools_agents_and_knowledge_bases['knowledge_bases']}
+        elif "knowledge_bases" in response and response['knowledge_bases'] is not None:  # after we have knowledge bases, we pass selected=True to mark that all selection were done
+            res["knowledge_bases"] = [a for a in tools_agents_and_knowledge_bases["knowledge_bases"] if
+                                      a["name"] in response["knowledge_bases"]]
+            message_content = {"selected": True}
+        elif "agent_name" in response and response['agent_name'] is not None:  # once we have a name and style, this phase has ended
+            res["agent_name"] = response["agent_name"]
+            res["agent_style"] = response["agent_style"]
             return res
         with _get_progress_spinner() as progress:
             task = progress.add_task(description="Thinking...", total=None)
@@ -194,6 +261,7 @@ def find_tools_by_description(description, tool_client):
             logger.warning("Failed to contact wxo server to fetch tools. Proceeding with empty tool list")
     return tools
 
+
 def find_agents(agent_client):
     with _get_progress_spinner() as progress:
         task = progress.add_task(description="Fetching Agents", total=None)
@@ -279,16 +347,25 @@ def prompt_tune(agent_spec: str, output_file: str | None, samples_file: str | No
     tools = _get_tools_from_names(agent.tools)
 
     collaborators = _get_agents_from_names(agent.collaborators)
+
+    knowledge_bases = _get_knowledge_bases_from_names(agent.knowledge_base)
     try:
-        new_prompt = talk_to_cpe(cpe_client=client, samples_file=samples_file,
-                                 context_data={"initial_instruction": instr, 'tools': tools, 'description': agent.description,
-                                               "collaborators": collaborators})
+        new_prompt = talk_to_cpe(cpe_client=client,
+                                samples_file=samples_file,
+                                context_data={
+                                    "initial_instruction": instr,
+                                    'tools': tools,
+                                    'description': agent.description,
+                                    "collaborators": collaborators,
+                                    "knowledge_bases": knowledge_bases
+                                })
     except ConnectionError:
         logger.error(
             "Failed to connect to Copilot server. Please ensure Copilot is running via `orchestrate copilot start`")
         sys.exit(1)
     except ClientAPIException:
-        logger.error("An unexpected server error has occur with in the Copilot server. Please check the logs via `orchestrate server logs`")
+        logger.error(
+            "An unexpected server error has occur with in the Copilot server. Please check the logs via `orchestrate server logs`")
         sys.exit(1)
 
     if new_prompt:
@@ -316,17 +393,21 @@ def create_agent(output_file: str, llm: str, samples_file: str | None, dry_run_f
             "Failed to connect to Copilot server. Please ensure Copilot is running via `orchestrate copilot start`")
         sys.exit(1)
     except ClientAPIException:
-        logger.error("An unexpected server error has occur with in the Copilot server. Please check the logs via `orchestrate server logs`")
+        logger.error(
+            "An unexpected server error has occur with in the Copilot server. Please check the logs via `orchestrate server logs`")
         sys.exit(1)
-        
+
     tools = res["tools"]
     collaborators = res["collaborators"]
+    knowledge_bases = res["knowledge_bases"]
     description = res["description"]
     agent_name = res["agent_name"]
     agent_style = res["agent_style"]
 
     # 4. discuss the instructions
-    instructions = talk_to_cpe(cpe_client, samples_file, {'description': description, 'tools': tools, 'collaborators': collaborators})
+    instructions = talk_to_cpe(cpe_client, samples_file,
+                               {'description': description, 'tools': tools, 'collaborators': collaborators,
+                                'knowledge_bases': knowledge_bases})
 
     # 6. create and save the agent
     llm = llm if llm else DEFAULT_LLM
@@ -334,7 +415,9 @@ def create_agent(output_file: str, llm: str, samples_file: str | None, dry_run_f
         'style': agent_style,
         'tools': [t['name'] for t in tools],
         'llm': llm,
-        'collaborators': [c['name'] for c in collaborators]
+        'collaborators': [c['name'] for c in collaborators],
+        'knowledge_base': [k['name'] for k in knowledge_bases]
+        # generate_agent_spec expects knowledge_base and not knowledge_bases
     }
     agent = AgentsController.generate_agent_spec(agent_name, AgentKind.NATIVE, description, **params)
     agent.instructions = instructions

ibm_watsonx_orchestrate/cli/commands/knowledge_bases/knowledge_bases_controller.py

@@ -72,6 +72,21 @@ class KnowledgeBaseController:
 
         knowledge_bases = parse_file(file=file)
         
+        if app_id:
+            connections_client = get_connections_client()
+            connection_id = None
+                
+            connections = connections_client.get_draft_by_app_id(app_id=app_id)
+            if not connections:
+                logger.error(f"No connection exists with the app-id '{app_id}'")
+                exit(1)
+
+            connection_id = connections.connection_id
+
+            for kb in knowledge_bases:
+                if kb.conversational_search_tool and kb.conversational_search_tool.index_config and len(kb.conversational_search_tool.index_config) > 0:
+                    kb.conversational_search_tool.index_config[0].connection_id = connection_id
+        
         existing_knowledge_bases = client.get_by_names([kb.name for kb in knowledge_bases])
         
         for kb in knowledge_bases:
@@ -97,18 +112,10 @@ class KnowledgeBaseController:
                     if len(kb.conversational_search_tool.index_config) != 1:
                         raise ValueError(f"Must provide exactly one conversational_search_tool.index_config. Provided {len(kb.conversational_search_tool.index_config)}.")
                     
-                    
-                    if app_id:
-                        connections_client = get_connections_client()
-                        connection_id = None
-                        if app_id is not None:
-                            connections = connections_client.get_draft_by_app_id(app_id=app_id)
-                            if not connections:
-                                logger.error(f"No connection exists with the app-id '{app_id}'")
-                                exit(1)
-
-                            connection_id = connections.connection_id
-                            kb.conversational_search_tool.index_config[0].connection_id = connection_id
+                    if (kb.conversational_search_tool.index_config[0].milvus or \
+                        kb.conversational_search_tool.index_config[0].elastic_search) and \
+                            not kb.conversational_search_tool.index_config[0].connection_id:
+                        raise ValueError(f"Must provide credentials (via --app-id) when using milvus or elastic_search.")
 
                     kb.prioritize_built_in_index = False
                     client.create(payload=kb.model_dump(exclude_none=True))

ibm_watsonx_orchestrate/cli/commands/models/model_provider_mapper.py

@@ -10,19 +10,23 @@ _BASIC_PROVIDER_CONFIG_KEYS = {'provider', 'api_key', 'custom_host', 'url_to_fet
 
 PROVIDER_EXTRA_PROPERTIES_LUT = {
     ModelProvider.ANTHROPIC: {'anthropic_beta', 'anthropic_version'},
-    # ModelProvider.AZURE_AI: {
-    #     'azure_resource_name',
-    #     'azure_deployment_id',
-    #     'azure_api_version',
-    #     'ad_auth',
-    #     'azure_auth_mode',
-    #     'azure_managed_client_id',
-    #     'azure_entra_client_id',
-    #     'azure_entra_client_secret',
-    #     'azure_entra_tenant_id',
-    #     'azure_ad_token',
-    #     'azure_model_name'
-    # },
+    ModelProvider.AZURE_AI: {
+        'azure_resource_name',
+        'azure_deployment_id',
+        'azure_api_version',
+        'ad_auth',
+        'azure_auth_mode',
+        'azure_managed_client_id',
+        'azure_entra_client_id',
+        'azure_entra_client_secret',
+        'azure_entra_tenant_id',
+        'azure_ad_token',
+        'azure_model_name',
+        'azure_inference_deployment_name',
+        'azure_inference_api_version',
+        'azure_inference_extra_params',
+        'azure_inference_foundry_url'
+    },
     ModelProvider.AZURE_OPENAI: {
         'azure_resource_name',
         'azure_deployment_id',

ibm_watsonx_orchestrate/cli/commands/server/server_command.py

@@ -370,9 +370,13 @@ def get_persisted_user_env() -> dict | None:
     user_env = cfg.get(USER_ENV_CACHE_HEADER) if cfg.get(USER_ENV_CACHE_HEADER) else None
     return user_env
 
-def run_compose_lite(final_env_file: Path, experimental_with_langfuse=False, experimental_with_ibm_telemetry=False, with_doc_processing=False) -> None:
-    
-    
+def run_compose_lite(
+        final_env_file: Path, 
+        experimental_with_langfuse=False, 
+        experimental_with_ibm_telemetry=False, 
+        with_doc_processing=False,
+        with_voice=False
+    ) -> None:
     compose_path = get_compose_file()
 
     compose_command = ensure_docker_compose_installed()
@@ -408,6 +412,8 @@ def run_compose_lite(final_env_file: Path, experimental_with_langfuse=False, exp
         profiles.append("ibm-telemetry")
     if with_doc_processing:
         profiles.append("docproc")
+    if with_voice:
+        profiles.append("voice")
 
     command = compose_command[:]
     for profile in profiles:
@@ -855,6 +861,11 @@ def server_start(
         '--compose-file', '-f',
         help='Provide the path to a custom docker-compose file to use instead of the default compose file'
     ),  
+    with_voice: bool = typer.Option(
+        False,
+        '--with-voice', '-v',
+        help='Enable voice controller to interact with the chat via voice channels'
+    ),
 ):
     confirm_accepts_license_agreement(accept_terms_and_conditions)
 
@@ -896,6 +907,7 @@ def server_start(
     if experimental_with_ibm_telemetry:
         merged_env_dict['USE_IBM_TELEMETRY'] = 'true'
 
+
     try:
         dev_edition_source = get_dev_edition_source(merged_env_dict)
         docker_login_by_dev_edition_source(merged_env_dict, dev_edition_source)
@@ -908,7 +920,8 @@ def server_start(
     run_compose_lite(final_env_file=final_env_file,
                      experimental_with_langfuse=experimental_with_langfuse,
                      experimental_with_ibm_telemetry=experimental_with_ibm_telemetry,
-                     with_doc_processing=with_doc_processing)
+                     with_doc_processing=with_doc_processing,
+                     with_voice=with_voice)
     
     run_db_migration()
 

ibm_watsonx_orchestrate/cli/commands/tools/tools_controller.py

@@ -464,6 +464,11 @@ The [bold]flow tool[/bold] is being imported from [green]`{file}`[/green].
                     continue
                 
                 model = obj().to_json()
+                # Ensure metadata exists and is correct
+                if "metadata" not in model or not isinstance(model["metadata"], dict):
+                    model["metadata"] = {}
+                if "source_kind" not in model["metadata"]:
+                    model["metadata"]["source_kind"] = "adk/python"
                 break
 
         elif file_path.suffix.lower() == ".json":
@@ -590,7 +595,7 @@ class ToolsController:
             for tool in tools:
                 tools_list.append(json.loads(tool.dumps_spec()))
 
-            rich.print(JSON(json.dumps(tools_list, indent=4)))
+            rich.print_json(json.dumps(tools_list, indent=4))
         else:
             table = rich.table.Table(show_header=True, header_style="bold white", show_lines=True)
             column_args = {

ibm_watsonx_orchestrate/cli/commands/voice_configurations/voice_configurations_command.py

@@ -0,0 +1,58 @@
+import sys
+from typing import Annotated
+import typer
+import logging
+
+from ibm_watsonx_orchestrate.cli.commands.voice_configurations.voice_configurations_controller import VoiceConfigurationsController
+
+logger = logging.getLogger(__name__)
+
+voice_configurations_app = typer.Typer(no_args_is_help=True)
+
+@voice_configurations_app.command(name="import", help="Import a voice configuration into the active environment from a file")
+def import_voice_config(
+  file: Annotated[
+    str,
+    typer.Option(
+      "--file",
+      "-f",
+      help="YAML file with voice configuraton definition"
+    )
+  ],
+):
+  voice_config_controller = VoiceConfigurationsController()
+  imported_config = voice_config_controller.import_voice_config(file)
+  voice_config_controller.publish_or_update_voice_config(imported_config)
+
+@voice_configurations_app.command(name="remove", help="Remove a voice configuration from the active environment")
+def remove_voice_config(
+  voice_config_name: Annotated[
+    str,
+    typer.Option(
+      "--name",
+      "-n",
+      help="name of the voice configuration to remove"
+    )
+  ] = None,
+):
+  voice_config_controller = VoiceConfigurationsController()
+  if voice_config_name:
+    voice_config_controller.remove_voice_config_by_name(voice_config_name)
+  else:
+    raise TypeError("You must specify the name of a voice configuration")
+    
+    
+
+@voice_configurations_app.command(name="list", help="List all voice configurations in the active environment")
+def list_voice_configs(
+  verbose: Annotated[
+    bool,
+    typer.Option(
+      "--verbose",
+      "-v",
+      help="List full details of all voice configurations in json format"
+    )
+  ] = False,
+):
+  voice_config_controller = VoiceConfigurationsController()
+  voice_config_controller.list_voice_configs(verbose)

ibm_watsonx_orchestrate/cli/commands/voice_configurations/voice_configurations_controller.py

@@ -0,0 +1,173 @@
+import json
+import sys
+import rich
+import yaml
+import logging
+from ibm_watsonx_orchestrate.agent_builder.voice_configurations import VoiceConfiguration
+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
+
+logger = logging.getLogger(__name__)
+
+class VoiceConfigurationsController:
+
+  def __init__(self):
+    self.voice_configs_client = None
+
+  def get_voice_configurations_client(self):
+    if not self.voice_configs_client:
+      self.voice_configs_client = instantiate_client(VoiceConfigurationsClient)
+    return self.voice_configs_client
+
+
+  def import_voice_config(self, file: str) -> VoiceConfiguration:
+
+    if file.endswith('.yaml') or file.endswith('.yml'):
+      with open(file, 'r') as f:
+        content = yaml.load(f, Loader=yaml.SafeLoader)
+
+    elif file.endswith(".json"):
+      with open(file, 'r') as f:
+        content = json.load(f)
+
+    else:
+      raise BadRequest("file must end in .yaml, .yml or .json")
+
+    return VoiceConfiguration.model_validate(content)
+
+
+  def fetch_voice_configs(self) -> list[VoiceConfiguration]:
+    client = self.get_voice_configurations_client()
+    res = client.list()
+
+    voice_configs = []
+
+    for config in res:
+      try:
+        voice_configs.append(VoiceConfiguration.model_validate(config))
+      except:
+        name = config.get('name', None)
+        logger.error(f"Config '{name}' could not be parsed")
+
+    return voice_configs
+  
+  def get_voice_config(self, voice_config_id: str) -> VoiceConfiguration | None:
+    client = self.get_voice_configurations_client()
+    return client.get(voice_config_id)
+
+  def get_voice_config_by_name(self, voice_config_name: str) -> VoiceConfiguration | None:
+    client = self.get_voice_configurations_client()
+    configs = client.get_by_name(voice_config_name)
+    if len(configs) == 0:
+      logger.error(f"No voice_configs with the name '{voice_config_name}' found. Failed to get config")
+      sys.exit(1)
+    
+    if len(configs) > 1:
+      logger.error(f"Multiple voice_configs with the name '{voice_config_name}' found. Failed to get config")
+      sys.exit(1)
+      
+    return configs[0]
+
+  def list_voice_configs(self, verbose: bool) -> 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))
+    else:
+      config_table = rich.table.Table(
+        show_header=True, 
+        header_style="bold white", 
+        title="Voice Configurations",
+        show_lines=True
+      )
+
+      column_args={
+        "Name" : {"overflow": "fold"},
+        "ID" : {"overflow": "fold"},
+        "STT Provider" : {"overflow": "fold"},
+        "TTS Provider" : {"overflow": "fold"},
+        "Attached Agents" : {}
+      }
+
+      for column in column_args:
+        config_table.add_column(column, **column_args[column])
+
+      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)
+        )
+      
+      rich.print(config_table)
+
+
+  def create_voice_config(self, voice_config: VoiceConfiguration) -> str | None:
+    client = self.get_voice_configurations_client()
+    res = client.create(voice_config)
+    config_id = res.get("id",None)
+    if config_id:
+      logger.info(f"Sucessfully created voice config '{voice_config['name']}'. id: '{config_id}'")
+    
+    return config_id
+
+
+  def update_voice_config_by_id(self, voice_config_id: str, voice_config: VoiceConfiguration) -> str | None:
+    client = self.get_voice_configurations_client()
+    res = client.update(voice_config_id,voice_config)
+    config_id = res.get("id",None)
+    if config_id:
+      logger.info(f"Sucessfully updated voice config '{voice_config['name']}'. id: '{config_id}'")
+
+    return config_id
+
+  def update_voice_config_by_name(self, voice_config_name: str, voice_config: VoiceConfiguration) -> str | None: 
+    client = self.get_voice_configurations_client()
+    existing_config = client.get_by_name(voice_config_name)
+
+    if existing_config and len(existing_config) > 0:
+      config_id = existing_config[0].voice_configuration_id
+      client.update(config_id,voice_config)
+    else:
+      logger.warning(f"Voice config '{voice_config_name}' not found, creating new config instead")
+      config_id = self.create_voice_config(voice_config)
+
+    return config_id
+
+  def publish_or_update_voice_config(self, voice_config: VoiceConfiguration) -> str | None:
+    client = self.get_voice_configurations_client()
+    voice_config_name = voice_config.name
+    existing_config = client.get_by_name(voice_config_name)
+
+    if existing_config and len(existing_config) > 0:
+      config_id = existing_config[0].voice_configuration_id
+      client.update(config_id,voice_config)
+    else:
+      client.create(voice_config)
+
+  def remove_voice_config_by_id(self, voice_config_id: str) -> None:
+    client = self.get_voice_configurations_client()
+    client.delete(voice_config_id)
+    logger.info(f"Sucessfully deleted voice config '{voice_config_id}'")
+
+  def remove_voice_config_by_name(self, voice_config_name: str) -> None:
+    client = self.get_voice_configurations_client()
+    voice_config = self.get_voice_config_by_name(voice_config_name)
+    if voice_config:
+      client.delete(voice_config.voice_configuration_id)
+      logger.info(f"Sucessfully deleted voice config '{voice_config_name}'")
+    else:
+      logger.info(f"Voice config '{voice_config_name}' not found")
+
+
+
+
+    
+    
+
+

ibm_watsonx_orchestrate/cli/main.py

@@ -16,6 +16,7 @@ from ibm_watsonx_orchestrate.cli.commands.knowledge_bases.knowledge_bases_comman
 from ibm_watsonx_orchestrate.cli.commands.toolkit.toolkit_command import toolkits_app
 from ibm_watsonx_orchestrate.cli.commands.evaluations.evaluations_command import evaluation_app
 from ibm_watsonx_orchestrate.cli.commands.copilot.copilot_command import copilot_app
+from ibm_watsonx_orchestrate.cli.commands.voice_configurations.voice_configurations_command import voice_configurations_app
 from ibm_watsonx_orchestrate.cli.init_helper import init_callback
 
 import urllib3
@@ -35,6 +36,7 @@ app.add_typer(tools_app, name="tools", help='Interact with the tools in your act
 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(voice_configurations_app, name="voice-configs", help="Configure voice providers to enable voice interaction with your agents")
 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')