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

ibm_watsonx_orchestrate/cli/commands/server/server_command.py

@@ -332,7 +332,6 @@ def write_merged_env_file(merged_env: dict, target_path: str = None) -> Path:
             file.write(f"{key}={val}\n")
     return Path(file.name)
 
-
 def get_dbtag_from_architecture(merged_env_dict: dict) -> str:
     """Detects system architecture and returns the corresponding DBTAG."""
     arch = platform.machine()
@@ -370,9 +369,14 @@ 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,
+        experimental_with_langflow=False,
+    ) -> None:
     compose_path = get_compose_file()
 
     compose_command = ensure_docker_compose_installed()
@@ -400,7 +404,11 @@ def run_compose_lite(final_env_file: Path, experimental_with_langfuse=False, exp
     logger.info("Database container started successfully. Now starting other services...")
 
 
-    # Step 2: Start all remaining services (except DB)
+    # Step 2: Create Langflow DB (if enabled)
+    if experimental_with_langflow:
+        create_langflow_db()
+
+    # Step 3: Start all remaining services (except DB)
     profiles = []
     if experimental_with_langfuse:
         profiles.append("langfuse")
@@ -408,6 +416,10 @@ 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")
+    if experimental_with_langflow:
+        profiles.append("langflow")
 
     command = compose_command[:]
     for profile in profiles:
@@ -659,7 +671,6 @@ def run_compose_lite_down(final_env_file: Path, is_reset: bool = False) -> None:
         )
         sys.exit(1)
 
-
 def run_compose_lite_logs(final_env_file: Path, is_reset: bool = False) -> None:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
@@ -855,6 +866,17 @@ 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'
+    ),
+    experimental_with_langflow: bool = typer.Option(
+        False,
+        '--experimental-with-langflow',
+        help='(Experimental) Enable Langflow UI, available at http://localhost:7861',
+        hidden=True
+    ),
 ):
     confirm_accepts_license_agreement(accept_terms_and_conditions)
 
@@ -896,6 +918,10 @@ def server_start(
     if experimental_with_ibm_telemetry:
         merged_env_dict['USE_IBM_TELEMETRY'] = 'true'
 
+    if experimental_with_langflow:
+        merged_env_dict['LANGFLOW_ENABLED'] = '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 +934,9 @@ 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,
+                     experimental_with_langflow=experimental_with_langflow)
     
     run_db_migration()
 
@@ -938,6 +966,8 @@ def server_start(
         logger.info(f"You can access the observability platform Langfuse at http://localhost:3010, username: orchestrate@ibm.com, password: orchestrate")
     if with_doc_processing:
         logger.info(f"Document processing in Flows (Public Preview) has been enabled.")
+    if experimental_with_langflow:
+        logger.info("Langflow has been enabled, the Langflow UI is available at http://localhost:7861")
 
 @server_app.command(name="stop")
 def server_stop(
@@ -1018,15 +1048,11 @@ def run_db_migration() -> None:
     merged_env_dict['ROUTING_LLM_API_KEY'] = ''
     merged_env_dict['ASSISTANT_LLM_API_KEY'] = ''
     final_env_file = write_merged_env_file(merged_env_dict)
+    
 
-    command = compose_command + [
-        "-f", str(compose_path),
-        "--env-file", str(final_env_file),
-        "exec",
-        "wxo-server-db",
-        "bash",
-        "-c",
-        '''
+    pg_user = merged_env_dict.get("POSTGRES_USER","postgres")
+
+    migration_command = f'''
         APPLIED_MIGRATIONS_FILE="/var/lib/postgresql/applied_migrations/applied_migrations.txt"
         touch "$APPLIED_MIGRATIONS_FILE"
 
@@ -1037,7 +1063,7 @@ def run_db_migration() -> None:
                 echo "Skipping already applied migration: $filename"
             else
                 echo "Applying migration: $filename"
-                if psql -U postgres -d postgres -q -f "$file" > /dev/null 2>&1; then
+                if psql -U {pg_user} -d postgres -q -f "$file" > /dev/null 2>&1; then
                     echo "$filename" >> "$APPLIED_MIGRATIONS_FILE"
                 else
                     echo "Error applying $filename. Stopping migrations."
@@ -1046,6 +1072,15 @@ def run_db_migration() -> None:
             fi
         done
         '''
+
+    command = compose_command + [
+        "-f", str(compose_path),
+        "--env-file", str(final_env_file),
+        "exec",
+        "wxo-server-db",
+        "bash",
+        "-c",
+        migration_command
     ]
 
     logger.info("Running Database Migration...")
@@ -1060,6 +1095,65 @@ def run_db_migration() -> None:
         )
         sys.exit(1)
 
+def create_langflow_db() -> None:
+    compose_path = get_compose_file()
+    compose_command = ensure_docker_compose_installed()
+    default_env_path = get_default_env_file()
+    merged_env_dict = merge_env(default_env_path, user_env_path=None)
+    merged_env_dict['WATSONX_SPACE_ID']='X'
+    merged_env_dict['WATSONX_APIKEY']='X'
+    merged_env_dict['WXAI_API_KEY'] = ''
+    merged_env_dict['ASSISTANT_EMBEDDINGS_API_KEY'] = ''
+    merged_env_dict['ASSISTANT_LLM_SPACE_ID'] = ''
+    merged_env_dict['ROUTING_LLM_SPACE_ID'] = ''
+    merged_env_dict['USE_SAAS_ML_TOOLS_RUNTIME'] = ''
+    merged_env_dict['BAM_API_KEY'] = ''
+    merged_env_dict['ASSISTANT_EMBEDDINGS_SPACE_ID'] = ''
+    merged_env_dict['ROUTING_LLM_API_KEY'] = ''
+    merged_env_dict['ASSISTANT_LLM_API_KEY'] = ''
+    final_env_file = write_merged_env_file(merged_env_dict)
+
+    pg_timeout = merged_env_dict.get('POSTGRES_READY_TIMEOUT','10')
+
+    pg_user = merged_env_dict.get("POSTGRES_USER","postgres")
+
+    creation_command = f"""
+    echo 'Waiting for pg to initialize...'
+
+    timeout={pg_timeout}
+    while [[ -z `pg_isready | grep 'accepting connections'` ]] && (( timeout > 0 )); do
+      ((timeout-=1)) && sleep 1;
+    done
+
+    if psql -U {pg_user} -lqt | cut -d \\| -f 1 | grep -qw langflow; then
+        echo 'Existing Langflow DB found'
+    else
+        echo 'Creating Langflow DB'
+        createdb -U "{pg_user}" -O "{pg_user}" langflow;
+        psql -U {pg_user} -q -d postgres -c "GRANT CONNECT ON DATABASE langflow TO {pg_user}";
+    fi
+    """
+    command = compose_command + [
+        "-f", str(compose_path),
+        "--env-file", str(final_env_file),
+        "exec",
+        "wxo-server-db",
+        "bash",
+        "-c",
+        creation_command
+    ]
+
+    logger.info("Preparing Langflow resources...")
+    result = subprocess.run(command, capture_output=False)
+
+    if result.returncode == 0:
+        logger.info("Langflow resources sucessfully created")
+    else:
+        error_message = result.stderr.decode('utf-8') if result.stderr else "Error occurred."
+        logger.error(
+            f"Failed to create Langflow resources\n{error_message}"
+        )
+        sys.exit(1)
 
 def bump_file_iteration(filename: str) -> str:
     regex = re.compile(f"^(?P<name>[^\\(\\s\\.\\)]+)(\\((?P<num>\\d+)\\))?(?P<type>\\.(?:{'|'.join(_EXPORT_FILE_TYPES)}))?$")

ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_command.py

@@ -1,7 +1,7 @@
 import typer
 from typing import List
 from typing_extensions import Annotated, Optional
-from ibm_watsonx_orchestrate.agent_builder.toolkits.types import ToolkitKind, Language
+from ibm_watsonx_orchestrate.agent_builder.toolkits.types import ToolkitKind, Language, ToolkitTransportKind
 from ibm_watsonx_orchestrate.cli.commands.toolkit.toolkit_controller import ToolkitController
 import logging
 import sys
@@ -45,6 +45,14 @@ def import_toolkit(
                 "The first argument will be used as the executable, the rest as its arguments."
         ),
     ] = None,
+    url: Annotated[
+        Optional[str],
+        typer.Option("--url", "-u", help="The URL of the remote MCP server", hidden=True),
+    ] = None,
+    transport: Annotated[
+        ToolkitTransportKind,
+        typer.Option("--transport", help="The communication protocol to use for the remote MCP server. Only \"sse\" or \"streamable_http\" supported", hidden=True),
+    ] = None,
     tools: Annotated[
         Optional[str],
         typer.Option("--tools", "-t", help="Comma-separated list of tools to import. Or you can use \"*\" to use all tools"),
@@ -64,18 +72,41 @@ def import_toolkit(
     else:
         tool_list = None
 
-    if not package and not package_root and not command:
-        logger.error("You must provide either '--package', '--package-root' or '--command'.")
-        sys.exit(1)
+    if not url and not transport:
+        if not package and not package_root and not command:
+            logger.error("You must provide either '--package', '--package-root' or '--command'.")
+            sys.exit(1)
 
-    if package_root and not command:
-        logger.error("Error: '--command' flag must be provided when '--package-root' is specified.")
-        sys.exit(1)
-    
-    if package_root and package:
-        logger.error("Please choose either '--package-root' or '--package' but not both.")
+        if package_root and not command:
+            logger.error("Error: '--command' flag must be provided when '--package-root' is specified.")
+            sys.exit(1)
+        
+        if package_root and package:
+            logger.error("Please choose either '--package-root' or '--package' but not both.")
+            sys.exit(1)
+
+    if (url and not transport) or (transport and not url):
+        logger.error("Both '--url' and '--transport' must be provided together for remote MCP.")
         sys.exit(1)
 
+    if url and transport:
+        forbidden_local_opts = []
+        if package:
+            forbidden_local_opts.append("--package")
+        if package_root:
+            forbidden_local_opts.append("--package-root")
+        if language:
+            forbidden_local_opts.append("--language")
+        if command:
+            forbidden_local_opts.append("--command")
+        
+        if forbidden_local_opts:
+            logger.error(
+                f"When using '--url' and '--transport' for a remote MCP, you cannot specify: "
+                f"{', '.join(forbidden_local_opts)}"
+            )
+            sys.exit(1)
+
     if package and not package_root:
         if not command:
             if language == Language.NODE:
@@ -97,6 +128,8 @@ def import_toolkit(
     package_root=package_root,
     language=language,
     command=command,
+    url=url,
+    transport=transport
 )
     toolkit_controller.import_toolkit(tools=tool_list, app_id=app_id)
 

ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_controller.py

@@ -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
+from ibm_watsonx_orchestrate.agent_builder.toolkits.types import ToolkitKind, Language, ToolkitSource, ToolkitTransportKind
 from ibm_watsonx_orchestrate.client.utils import instantiate_client
 from ibm_watsonx_orchestrate.utils.utils import sanatize_app_id
 from ibm_watsonx_orchestrate.client.connections import get_connections_client
@@ -26,15 +26,16 @@ import json
 
 logger = logging.getLogger(__name__)
 
-def get_connection_id(app_id: str) -> str:
+def get_connection_id(app_id: str, is_local_mcp: bool) -> str:
     connections_client = get_connections_client()
     existing_draft_configuration = connections_client.get_config(app_id=app_id, env='draft')
     existing_live_configuration = connections_client.get_config(app_id=app_id, env='live')
 
     for config in [existing_draft_configuration, existing_live_configuration]:
-        if config and config.security_scheme != 'key_value_creds':
-            logger.error("Only key_value credentials are currently supported")
-            exit(1)
+        if is_local_mcp is True:
+            if config and config.security_scheme != 'key_value_creds':
+                logger.error("Only key_value credentials are currently supported for local MCP")
+                exit(1)
     connection_id = None
     if app_id is not None:
         connection = connections_client.get(app_id=app_id)
@@ -59,6 +60,8 @@ class ToolkitController:
         package_root: str = None,
         language: Language = None,
         command: str = None,
+        url: str = None,
+        transport: ToolkitTransportKind = None
     ):
         self.kind = kind
         self.name = name
@@ -68,6 +71,8 @@ class ToolkitController:
         self.language = language
         self.command = command
         self.client = None
+        self.url = url
+        self.transport = transport
 
         self.source: ToolkitSource = (
             ToolkitSource.FILES if package_root else ToolkitSource.PUBLIC_REGISTRY
@@ -95,15 +100,23 @@ class ToolkitController:
             logger.error(f"Existing toolkit found with name '{self.name}'. Failed to create toolkit.")
             sys.exit(1)
 
-        try:
-            command_parts = json.loads(self.command)
-            if not isinstance(command_parts, list):
-                raise ValueError("JSON command must be a list of strings")
-        except (json.JSONDecodeError, ValueError):
-            command_parts = self.command.split()
+        if not self.command:
+            command_parts = []
+        else:
+            try:
+                command_parts = json.loads(self.command)
+                if not isinstance(command_parts, list):
+                    raise ValueError("JSON command must be a list of strings")
+            except (json.JSONDecodeError, ValueError):
+                command_parts = self.command.split()
+
+        if command_parts:
+            command = command_parts[0]
+            args = command_parts[1:]
+        else:
+            command = None
+            args = []
 
-        command = command_parts[0]
-        args = command_parts[1:]
 
         if self.package_root:
             is_folder = os.path.isdir(self.package_root)
@@ -150,18 +163,31 @@ class ToolkitController:
                     console.print(f"  • {tool}")
 
             # Create toolkit metadata
-            payload = {
-                "name": self.name,
-                "description": self.description,
-                "mcp": {
-                    "source": self.source.value,
-                    "command": command,
-                    "args": args,
-                    "tools": tools,
-                    "connections": remapped_connections,
+            payload = {}
+
+            if self.transport is not None and self.url is not None:
+                payload = {
+                    "name": self.name,
+                    "description": self.description,
+                    "mcp": {
+                        "server_url": self.url,
+                        "transport": self.transport.value,
+                        "tools": tools,
+                        "connections": remapped_connections,
+                    }
+                }
+            else:
+                payload = {
+                    "name": self.name,
+                    "description": self.description,
+                    "mcp": {
+                        "source": self.source.value,
+                        "command": command,
+                        "args": args,
+                        "tools": tools,
+                        "connections": remapped_connections,
+                    }
                 }
-            }
-
 
             with Progress(
                 SpinnerColumn(spinner_name="dots"),
@@ -215,7 +241,8 @@ class ToolkitController:
                 raise typer.BadParameter(f"The provided --app-id '{app_id}' is not valid. --app-id cannot be empty or whitespace")
 
             runtime_id = sanatize_app_id(runtime_id)
-            app_id_dict[runtime_id] = get_connection_id(local_id)
+            is_local_mcp = self.package is not None or self.package_root is not None
+            app_id_dict[runtime_id] = get_connection_id(local_id, is_local_mcp)
 
         return app_id_dict
 

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

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")
+
+
+
+
+    
+    
+
+