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

ibm_watsonx_orchestrate/__init__.py

@@ -5,7 +5,8 @@
 
 pkg_name = "ibm-watsonx-orchestrate"
 
-__version__ = "1.9.0b2"
+__version__ = "1.10.0b0"
+
 
 
 

ibm_watsonx_orchestrate/agent_builder/agents/types.py

@@ -77,6 +77,8 @@ class BaseAgentSpec(BaseModel):
     description: Annotated[str, Field(json_schema_extra={"min_length_str":1})]
     context_access_enabled: bool = True
     context_variables: Optional[List[str]] = []
+    voice_configuration_id: Optional[str] = None
+    voice_configuration: Optional[str] = None
 
     def dump_spec(self, file: str) -> None:
         dumped = self.model_dump(mode='json', exclude_unset=True, exclude_none=True)

ibm_watsonx_orchestrate/agent_builder/tools/python_tool.py

@@ -187,15 +187,27 @@ def _fix_optional(schema):
     replacements = {}
     if schema.required is None:
         schema.required = []
-
     for k, v in schema.properties.items():
+        # Simple null type & required -> not required
         if v.type == 'null' and k in schema.required:
             not_required.append(k)
-        if v.anyOf is not None and next(filter(lambda x: x.type == 'null', v.anyOf)) and k in schema.required:
-            v.anyOf = list(filter(lambda x: x.type != 'null', v.anyOf))
-            if len(v.anyOf) == 1:
-                replacements[k] = v.anyOf[0]
-            not_required.append(k)
+        # Optional with null & required
+        if v.anyOf is not None and [x for x in v.anyOf if x.type == 'null']:
+            if k in schema.required:
+            # required with default -> not required 
+            # required without default -> required & remove null from union
+                if v.default:
+                    not_required.append(k)
+                else:
+                    v.anyOf = list(filter(lambda x: x.type != 'null', v.anyOf))
+                if len(v.anyOf) == 1:
+                    replacements[k] = v.anyOf[0]
+            else:
+            # not required with default -> no change
+            # not required without default -> means default input is 'None'
+                v.default = v.default if v.default else 'null'
+
+
     schema.required = list(filter(lambda x: x not in not_required, schema.required if schema.required is not None else []))
     for k, v in replacements.items():
         combined = {
@@ -204,7 +216,7 @@ def _fix_optional(schema):
         }
         schema.properties[k] = JsonSchemaObject(**combined)
         schema.properties[k].anyOf = None
-
+        
     for k in schema.properties.keys():
         if schema.properties[k].type == 'object':
             schema.properties[k] = _fix_optional(schema.properties[k])

ibm_watsonx_orchestrate/agent_builder/voice_configurations/__init__.py

@@ -0,0 +1 @@
+from .types import VoiceConfiguration

ibm_watsonx_orchestrate/agent_builder/voice_configurations/types.py

@@ -0,0 +1,98 @@
+import json
+from typing import Annotated, Optional, List, Dict
+from pydantic import BaseModel, Field, model_validator
+
+def _validate_exactly_one_of_fields(object: BaseModel, object_name: str, fields: list[str]):
+  present_fields = [getattr(object,field) for field in fields if getattr(object,field) is not None]
+
+  if len(present_fields) != 1:
+    raise ValueError(f"{object_name} requires exactly one of {','.join(fields)}")
+
+
+def _validate_language_uniqueness(config: BaseModel):
+  if hasattr(config,'language') and hasattr(config,'additional_languages'):
+    if config.language and config.additional_languages and config.language in config.additional_languages:
+      raise ValueError(f"Language '{config.language}' cannot be in both the default language and additional_languages")
+
+
+class WatsonSTTConfig(BaseModel):
+  api_url: Annotated[str, Field(min_length=1,max_length=2048)]
+  api_key: Optional[Annotated[str, Field(min_length=1,max_length=2048)]] = None
+  bearer_token: Optional[Annotated[str, Field(min_length=1,max_length=2048)]] = None
+  model: Annotated[str, Field(min_length=1,max_length=256)]
+
+class EmotechSTTConfig(BaseModel):
+  api_key: Annotated[str,Field(min_length=1,max_length=2048)]
+  api_url: Annotated[str,Field(min_length=1,max_length=2048)]
+
+
+class SpeechToTextConfig(BaseModel):
+  provider: Annotated[str, Field(min_length=1,max_length=128)]
+  watson_stt_config: Optional[WatsonSTTConfig] = None
+  emotech_stt_config: Optional[EmotechSTTConfig] = None
+
+  @model_validator(mode='after')
+  def validate_providers(self):
+    _validate_exactly_one_of_fields(self,'SpeechToTextConfig',['watson_stt_config','emotech_stt_config'])
+    return self
+
+class WatsonTTSConfig(BaseModel):
+  api_url: Annotated[str, Field(min_length=1,max_length=2048)]
+  api_key: Optional[Annotated[str, Field(min_length=1,max_length=2048)]] = None
+  bearer_token: Optional[Annotated[str, Field(min_length=1,max_length=2048)]] = None
+  voice: Annotated[str, Field(min_length=1,max_length=128)]
+  rate_percentage: Optional[int] = None
+  pitch_percentage: Optional[int] = None
+  language: Optional[str] = None
+
+class EmotechTTSConfig(BaseModel):
+  api_url: Annotated[str, Field(min_length=1,max_length=2048)]
+  api_key: Annotated[str, Field(min_length=1,max_length=2048)]
+  voice: Optional[Annotated[str, Field(min_length=1,max_length=128)]]
+
+class TextToSpeechConfig(BaseModel):
+  provider: Annotated[str, Field(min_length=1,max_length=128)]
+  watson_tts_config: Optional[WatsonTTSConfig] = None
+  emotech_tts_config: Optional[EmotechTTSConfig] = None
+
+  @model_validator(mode='after')
+  def validate_providers(self):
+    _validate_exactly_one_of_fields(self,'TextToSpeechConfig',['watson_tts_config','emotech_tts_config'])
+    return self
+
+class AdditionalProperties(BaseModel):
+  speech_to_text: Optional[SpeechToTextConfig] = None
+  text_to_speech: Optional[TextToSpeechConfig] = None
+
+class DTMFInput(BaseModel):
+  inter_digit_timeout_ms: Optional[int] = None
+  termination_key: Optional[str] = None
+  maximum_count: Optional[int] = None
+  ignore_speech: Optional[bool] = None
+
+class AttachedAgent(BaseModel):
+  id: str
+  name: Optional[str] = None
+  display_name: Optional[str] = None
+
+class VoiceConfiguration(BaseModel):
+  name: Annotated[str, Field(min_length=1,max_length=128)]
+  speech_to_text: SpeechToTextConfig
+  text_to_speech: TextToSpeechConfig
+  language: Optional[Annotated[str,Field(min_length=2,max_length=16)]] = None
+  additional_languages: Optional[dict[str,AdditionalProperties]] = None
+  dtmf_input: Optional[DTMFInput] = None
+  voice_configuration_id: Optional[str] = None
+  tenant_id: Optional[Annotated[str, Field(min_length=1,max_length=128)]] = None
+  attached_agents: Optional[list[AttachedAgent]] = None
+
+  @model_validator(mode='after')
+  def validate_language(self):
+    _validate_language_uniqueness(self)
+    return self
+
+  def dumps_spec(self) -> str:
+    dumped = self.model_dump(mode='json', exclude_none=True)
+    return json.dumps(dumped, indent=2)
+
+

ibm_watsonx_orchestrate/cli/commands/agents/agents_command.py

@@ -253,3 +253,23 @@ def export_agent(
 ):  
     agents_controller = AgentsController()
     agents_controller.export_agent(name=name, kind=kind, output_path=output_file, agent_only_flag=agent_only_flag)
+
+@agents_app.command(name="deploy", help="Deploy Agent")
+def deploy_agent(
+    name: Annotated[
+        str,
+        typer.Option("--name", "-n", help="Name of the agent you wish to deploy"),
+    ]
+):
+    agents_controller = AgentsController()
+    agents_controller.deploy_agent(name=name)
+
+@agents_app.command(name="undeploy", help="Undeploy Agent")
+def undeploy_agent(
+    name: Annotated[
+        str,
+        typer.Option("--name", "-n", help="Name of the agent you wish to undeploy"),
+    ]
+):
+    agents_controller = AgentsController()
+    agents_controller.undeploy_agent(name=name)

ibm_watsonx_orchestrate/cli/commands/agents/agents_controller.py

@@ -29,13 +29,17 @@ from ibm_watsonx_orchestrate.client.agents.agent_client import AgentClient, Agen
 from ibm_watsonx_orchestrate.client.agents.external_agent_client import ExternalAgentClient
 from ibm_watsonx_orchestrate.client.agents.assistant_agent_client import AssistantAgentClient
 from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
+from ibm_watsonx_orchestrate.client.voice_configurations.voice_configurations_client import VoiceConfigurationsClient
 from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 from ibm_watsonx_orchestrate.client.connections import get_connections_client
 from ibm_watsonx_orchestrate.client.knowledge_bases.knowledge_base_client import KnowledgeBaseClient
 
-from ibm_watsonx_orchestrate.client.utils import instantiate_client
+from ibm_watsonx_orchestrate.client.utils import instantiate_client, is_local_dev
 from ibm_watsonx_orchestrate.utils.utils import check_file_in_zip
 
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
 logger = logging.getLogger(__name__)
 
 # Helper generic type for any agent
@@ -197,6 +201,7 @@ def get_app_id_from_conn_id(conn_id: str) -> str:
         exit(1)
     return app_id
 
+
 def get_agent_details(name: str, client: AgentClient | ExternalAgentClient | AssistantAgentClient) -> dict:
     agent_specs = client.get_draft_by_name(name)
     if len(agent_specs) > 1:
@@ -219,6 +224,7 @@ class AgentsController:
         self.assistant_client = None
         self.tool_client = None
         self.knowledge_base_client = None
+        self.voice_configuration_client = None
 
     def get_native_client(self):
         if not self.native_client:
@@ -245,6 +251,11 @@ class AgentsController:
             self.knowledge_base_client = instantiate_client(KnowledgeBaseClient)
         return self.knowledge_base_client
     
+    def get_voice_configuration_client(self):
+        if not self.voice_configuration_client:
+            self.voice_configuration_client = instantiate_client(VoiceConfigurationsClient)
+        return self.voice_configuration_client
+    
     @staticmethod
     def import_agent(file: str, app_id: str) -> List[Agent | ExternalAgent | AssistantAgent]:
         agents = parse_file(file)
@@ -520,6 +531,38 @@ class AgentsController:
                 guideline.tool = name
 
         return ref_agent
+    
+    def get_voice_config_name_from_id(self, voice_config_id: str) -> str | None:
+        client = self.get_voice_configuration_client()
+        config = client.get_by_id(voice_config_id)
+        return config.name if config else None
+
+    def get_voice_config_id_from_name(self, voice_config_name: str) -> str | None:
+        client = self.get_voice_configuration_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].voice_configuration_id
+
+
+    def reference_voice_config(self,agent: Agent):
+        deref_agent = deepcopy(agent)
+        deref_agent.voice_configuration = self.get_voice_config_name_from_id(agent.voice_configuration_id)
+        del deref_agent.voice_configuration_id
+        return deref_agent
+
+    def dereference_voice_config(self,agent: Agent):
+        ref_agent = deepcopy(agent)
+        ref_agent.voice_configuration_id = self.get_voice_config_id_from_name(agent.voice_configuration)
+        del ref_agent.voice_configuration
+        return ref_agent
 
     @staticmethod
     def dereference_app_id(agent: ExternalAgent | AssistantAgent) -> ExternalAgent | AssistantAgent:
@@ -540,7 +583,18 @@ class AgentsController:
             agent.config.connection_id = None
 
         return agent
+    
+    def dereference_common_agent_dependencies(self, agent: AnyAgentT) -> AnyAgentT:
+        if agent.voice_configuration:
+            agent = self.dereference_voice_config(agent)
+
+        return agent  
+
+    def reference_common_agent_dependencies(self, agent: AnyAgentT) -> AnyAgentT:
+        if agent.voice_configuration_id:
+            agent = self.reference_voice_config(agent)
 
+        return agent
 
     def dereference_native_agent_dependencies(self, agent: Agent) -> Agent:
         if agent.collaborators and len(agent.collaborators):
@@ -584,6 +638,8 @@ class AgentsController:
     
     # Convert all names used in an agent to the corresponding ids
     def dereference_agent_dependencies(self, agent: AnyAgentT) -> AnyAgentT:
+
+        agent = self.dereference_common_agent_dependencies(agent)
         if isinstance(agent, Agent):
             return self.dereference_native_agent_dependencies(agent)
         if isinstance(agent, ExternalAgent) or isinstance(agent, AssistantAgent):
@@ -591,6 +647,8 @@ class AgentsController:
 
     # Convert all ids used in an agent to the corresponding names
     def reference_agent_dependencies(self, agent: AnyAgentT) -> AnyAgentT:
+
+        agent = self.reference_common_agent_dependencies(agent)
         if isinstance(agent, Agent):
             return self.reference_native_agent_dependencies(agent)
         if isinstance(agent, ExternalAgent) or isinstance(agent, AssistantAgent):
@@ -1111,3 +1169,114 @@ class AgentsController:
             logger.info(f"Successfully wrote agents and tools to '{output_path}'")
             zip_file_out.close()
 
+
+    def deploy_agent(self, name: str):
+        if is_local_dev():
+            logger.error("Agents cannot be deployed in Developer Edition")
+            sys.exit(1)
+        native_client = self.get_native_client()
+        external_client = self.get_external_client()
+        assistant_client = self.get_assistant_client()
+
+        existing_native_agents = native_client.get_draft_by_name(name)
+        existing_external_agents = external_client.get_draft_by_name(name)
+        existing_assistant_agents = assistant_client.get_draft_by_name(name)
+
+        if len(existing_native_agents) == 0 and (len(existing_external_agents) >= 1 or len(existing_assistant_agents) >= 1):
+            logger.error(f"No native agent found with name '{name}'. Only Native Agents can be deployed to a Live Environment")
+            sys.exit(1)
+        if len(existing_native_agents) > 1:
+            logger.error(f"Multiple native agents with the name '{name}' found. Failed to get agent")
+            sys.exit(1)
+        if len(existing_native_agents) == 0:
+            logger.error(f"No native agents with the name '{name}' found. Failed to get agent")
+            sys.exit(1)
+            
+
+        agent_details = existing_native_agents[0]
+        agent_id = agent_details.get("id")
+
+        environments = native_client.get_environments_for_agent(agent_id)
+
+        live_environment = [env for env in environments if env.get("name") == "live"]
+        if live_environment is None:
+            logger.error("No live environment found for this tenant")
+            sys.exit(1)
+
+        live_env_id = live_environment[0].get("id")
+
+        console = Console()
+        with Progress(
+            SpinnerColumn(spinner_name="dots"),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+            console=console,
+                ) as progress:
+                    progress.add_task(description="Deploying agent to Live envrionment", total=None)
+
+                    status = native_client.deploy(agent_id, live_env_id)
+
+        if status:
+            logger.info(f"Successfully deployed agent {name}")
+        else:
+            logger.error(f"Error deploying agent {name}")
+
+    def undeploy_agent(self, name: str):
+        if is_local_dev():
+            logger.error("Agents cannot be undeployed in Developer Edition")
+            sys.exit(1)
+        
+        native_client = self.get_native_client()
+        external_client = self.get_external_client()
+        assistant_client = self.get_assistant_client()
+
+        existing_native_agents = native_client.get_draft_by_name(name)
+        existing_external_agents = external_client.get_draft_by_name(name)
+        existing_assistant_agents = assistant_client.get_draft_by_name(name)
+
+        if len(existing_native_agents) == 0 and (len(existing_external_agents) >= 1 or len(existing_assistant_agents) >= 1):
+            logger.error(f"No native agent found with name '{name}'. Only Native Agents can be undeployed from a Live Environment")
+            sys.exit(1)
+        if len(existing_native_agents) > 1:
+            logger.error(f"Multiple native agents with the name '{name}' found. Failed to get agent")
+            sys.exit(1)
+        if len(existing_native_agents) == 0:
+            logger.error(f"No native agents with the name '{name}' found. Failed to get agent")
+            sys.exit(1)
+
+        agent_details = existing_native_agents[0]
+        agent_id = agent_details.get("id")
+
+        environments = native_client.get_environments_for_agent(agent_id)
+        live_environment = [env for env in environments if env.get("name") == "live"]
+        if live_environment is None:
+            logger.error("No live environment found for this tenant")
+            sys.exit(1)
+        version_id = live_environment[0].get("current_version")
+
+        if version_id is None:
+            agent_name = agent_details.get("name")
+            logger.error(f"Agent {agent_name} does not exist in a Live environment")
+            sys.exit(1)
+
+        draft_environment = [env for env in environments if env.get("name") == "draft"]
+        if draft_environment is None:
+            logger.error("No draft environment found for this tenant")
+            sys.exit(1)
+        draft_env_id = draft_environment[0].get("id")
+
+        console = Console()
+        with Progress(
+            SpinnerColumn(spinner_name="dots"),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+            console=console,
+                ) as progress:
+                    progress.add_task(description="Undeploying agent to Draft envrionment", total=None)
+
+                    status = native_client.undeploy(agent_id, version_id, draft_env_id)
+        if status:
+            logger.info(f"Successfully undeployed agent {name}")
+        else:
+            logger.error(f"Error undeploying agent {name}")
+

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

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')

ibm_watsonx_orchestrate/client/agents/agent_client.py

@@ -1,7 +1,26 @@
 from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
 from typing_extensions import List, Optional
+from enum import Enum
+
 from ibm_watsonx_orchestrate.client.utils import is_local_dev
 from pydantic import BaseModel
+import time
+import logging
+
+logger = logging.getLogger(__name__)
+
+POLL_INTERVAL = 2
+MAX_RETRIES = 10
+
+class ReleaseMode(str, Enum):
+    DEPLOY = "deploy"
+    UNDEPLOY = "undeploy"
+
+class ReleaseStatus(str, Enum):
+    SUCCESS = "success"
+    NONE = "none"
+    FAILED = "failed"
+    IN_PROGRESS = "in_progress"
 
 def transform_agents_from_flat_agent_spec(agents: dict | list[dict] ) -> dict | list[dict]:
     if isinstance(agents,list):
@@ -83,7 +102,6 @@ class AgentClient(BaseAPIClient):
         super().__init__(*args, **kwargs)
         self.base_endpoint = "/orchestrate/agents" if is_local_dev(self.base_url) else "/agents"
 
-
     def create(self, payload: dict) -> AgentUpsertResponse:
         response = self._post(self.base_endpoint, data=transform_agents_from_flat_agent_spec(payload))
         return AgentUpsertResponse.model_validate(response)
@@ -120,4 +138,49 @@ class AgentClient(BaseAPIClient):
     def get_drafts_by_ids(self, agent_ids: List[str]) -> List[dict]:
         formatted_agent_ids = [f"ids={x}" for x  in agent_ids]
         return transform_agents_to_flat_agent_spec(self._get(f"{self.base_endpoint}?{'&'.join(formatted_agent_ids)}&include_hidden=true"))
+
+    def poll_release_status(self, agent_id: str, environment_id: str, mode: str = "deploy") -> bool:
+        expected_status = {
+            ReleaseMode.DEPLOY: ReleaseStatus.SUCCESS,
+            ReleaseMode.UNDEPLOY: ReleaseStatus.NONE
+        }[mode]
+
+        for attempt in range(MAX_RETRIES):
+            try:
+                response = self._get(
+                    f"{self.base_endpoint}/{agent_id}/releases/status?environment_id={environment_id}"
+                )
+            except Exception as e:
+                logger.error(f"Polling for Deployment/Undeployment failed on attempt {attempt + 1}: {e}")
+                return False
+
+            if not isinstance(response, dict):
+                logger.warning(f"Invalid response format: {response}")
+                return False
+            
+            status = response.get("deployment_status")
+
+            if status == expected_status:
+                return True
+            elif status == "failed":
+                return False
+            elif status == "in_progress":
+                pass
+
+            time.sleep(POLL_INTERVAL)
+
+        logger.warning(f"{mode.capitalize()} status polling timed out")
+        return False
+
+    def deploy(self, agent_id: str, environment_id: str) -> bool:
+        self._post(f"{self.base_endpoint}/{agent_id}/releases", data={"environment_id": environment_id})
+        return self.poll_release_status(agent_id, environment_id, mode=ReleaseMode.DEPLOY)
+
+    def undeploy(self, agent_id: str, version: str, environment_id: str) -> bool:
+        self._post(f"{self.base_endpoint}/{agent_id}/releases/{version}/undeploy")
+        return self.poll_release_status(agent_id, environment_id, mode=ReleaseMode.UNDEPLOY)
+    
+    def get_environments_for_agent(self, agent_id: str):
+        return self._get(f"{self.base_endpoint}/{agent_id}/environment")
+
     

ibm_watsonx_orchestrate/client/voice_configurations/voice_configurations_client.py

@@ -0,0 +1,75 @@
+from pydantic import ValidationError
+from ibm_watsonx_orchestrate.agent_builder.voice_configurations import VoiceConfiguration
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
+from ibm_watsonx_orchestrate.client.client_errors import MissingArgument
+
+import logging
+logger = logging.getLogger(__name__)
+
+class VoiceConfigurationsClient(BaseAPIClient):
+
+  def create(self, voice_config: VoiceConfiguration) -> dict:
+    return self._post("/voice_configurations", data=voice_config.model_dump(exclude_none=True))
+
+
+  def update(self, voice_config_id: str, voice_config: VoiceConfiguration) -> dict:    
+    if voice_config_id in [None,""]:
+      raise MissingArgument("voice_config_id")
+    return self._patch(f"/voice_configurations/{voice_config_id}", data=voice_config.model_dump(exclude_none=True))
+
+
+  def get_by_id(self, voice_config_id: str) -> dict | None:
+    if voice_config_id in [None,""]:
+      raise MissingArgument("voice_config_id")
+    
+    try:
+      response = self._get(f"/voice_configurations/{voice_config_id}")
+      return VoiceConfiguration.model_validate(response)
+    
+    except ClientAPIException as e:
+      if e.response.status_code == 404:
+        return None
+      raise e
+    
+    except ValidationError as e:
+      logger.error("Recieved unexpected response from server")
+      raise e
+    
+  def get_by_name(self, name: str) -> list[VoiceConfiguration]:
+    return self.get_by_names([name])
+
+  def get_by_names(self, names: list[str]) -> list[VoiceConfiguration]:
+    # server will implement query by name, below can be uncommented then
+    # formatted_config_names = [f"names={n}" for n in names]
+    # return self._get(f"/voice_configurations?{"&".join(formatted_config_names)}")
+    config_list = self.list()
+    filtered_list = [cfg for cfg in config_list if cfg.name in names]
+
+    try:
+      return [ VoiceConfiguration.model_validate(cfg) for cfg in filtered_list ]
+    except ValidationError as e:
+      logger.error("Recieved unexpected response from server")
+      raise e
+
+
+
+
+  def delete(self, voice_config_id: str) -> None:
+    if voice_config_id in [None,""]:
+      raise MissingArgument("voice_config_id")
+    self._delete(f"/voice_configurations/{voice_config_id}")
+
+
+  def list(self) -> list[dict]:
+    try:
+      response = self._get("/voice_configurations")
+      return [VoiceConfiguration.model_validate(x) for x in response.get('voice_configurations',[])]
+    
+    except ClientAPIException as e:
+      if e.response.status_code == 404:
+        return []
+      raise e
+    
+    except ValidationError as e:
+      logger.error("Recieved unexpected response from server")
+      raise e

ibm_watsonx_orchestrate/docker/compose-lite.yml

@@ -102,6 +102,7 @@ services:
       DISMISS_NOTIFICATION_TIMEOUT: 10000
       STANDALONE: "true"
       STREAM_TIMEOUT: ${STREAM_TIMEOUT:-120000}
+      WXO_VOICE_URL: http://localhost:9876/v1
     command: "./StartServer.sh"
     ports:
       - "3000:4002"
@@ -342,6 +343,7 @@ services:
       AGENTOPS_API_KEY_AUTH_ENABLED: ${AGENTOPS_API_KEY_AUTH_ENABLED:-false}
       AGENTOPS_API_KEY: ${AGENTOPS_API_KEY}
       ES_HOST: http://elasticsearch:9200
+      ORIGIN_HEADER: "internal"
 
   wxo-server-worker:
     image: ${WORKER_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-server-conversation_controller:${WORKER_TAG:-latest}
@@ -517,7 +519,7 @@ services:
   # IBM AGENT-OPS
   ########################
   elasticsearch:
-    image: docker.elastic.co/elasticsearch/elasticsearch:8.17.5
+    image: docker.elastic.co/elasticsearch/elasticsearch:8.19.0
     profiles: [ibm-telemetry]
     environment:
       - discovery.type=single-node
@@ -794,6 +796,7 @@ services:
       WO_INSTANCE: ${WO_INSTANCE}
       AUTHORIZATION_URL: ${AUTHORIZATION_URL}
       WO_AUTH_TYPE: ${WO_AUTH_TYPE}
+      FLOW_CALLBACK_REQUEST_RETRIES: "1"
     healthcheck:
       test: curl -k http://localhost:9044/readiness --fail
       interval: 30s
@@ -1092,6 +1095,17 @@ services:
       exit 0;
       "
 
+  wxo-server-voice:
+      image: ${VOICE_CONTROLLER_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-server-voice:${VOICE_CONTROLLER_TAG:-latest}
+      profiles: [voice]
+      restart: unless-stopped
+      ports: 
+        - 9876:8765
+      environment:
+        WXO_BASE_DOMAIN_URL: "http://wxo-server:4321"
+        AI_GATEWAY_URL: "http://ai-gateway:8787"
+        WXO_ORIGIN_HEADER: "internal"
+
 volumes:
   tools:
     driver: local

ibm_watsonx_orchestrate/docker/default.env

@@ -57,10 +57,10 @@ EVENT_BROKER_TTL="3600"
 REGISTRY_URL=
 
 
-SERVER_TAG=01-08-2025
+SERVER_TAG=13-08-2025-b01e43e00a7c900f92057d63520be08f965b6b24
 SERVER_REGISTRY=
 
-WORKER_TAG=01-08-2025-v2
+WORKER_TAG=13-08-2025-b01e43e00a7c900f92057d63520be08f965b6b24
 WORKER_REGISTRY=
 
 AI_GATEWAY_TAG=01-08-2025-v1
@@ -82,16 +82,16 @@ UITAG=31-07-2025
 CM_REGISTRY=
 CM_TAG=24-07-2025
 
-TRM_TAG=23-07-2025-3c60549f0bac275de3e5736265a3fd49cdd3a203
+TRM_TAG=12-08-2025-5f816b3d5981afdd65fa55401d70e5aa5f734fc4
 TRM_REGISTRY=
 
-TR_TAG=23-07-2025-3c60549f0bac275de3e5736265a3fd49cdd3a203
+TR_TAG=14-08-2025-7b2f9c9
 TR_REGISTRY=
 
-BUILDER_TAG=31-07-2025-d7145cb
+BUILDER_TAG=12-08-2025-8f00997
 BUILDER_REGISTRY=
 
-FLOW_RUNTIME_TAG=01-08-2025
+FLOW_RUNTIME_TAG=11-08-2025
 FLOW_RUMTIME_REGISTRY=
 
 
@@ -107,6 +107,9 @@ SOCKET_HANDLER_REGISTRY=
 CPE_TAG=06-08-2025-b0a20ad
 CPE_REGISTRY=
 
+VOICE_CONTROLLER_TAG=12-08-2025
+VOICE_CONTROLLER_REGISTRY=
+
 # IBM Document Processing
 WDU_TAG=2.5.0
 WDU_REGISTRY=

ibm_watsonx_orchestrate/flow_builder/flows/flow.py

@@ -115,6 +115,10 @@ class Flow(Node):
                 # we need a deep compare if the incoming schema and existing_schema is the same
                 # pydantic suppport nested comparison by default
 
+                if isinstance(schema, dict):
+                    # recast schema to support direct access
+                    schema = JsonSchemaObject.model_validate(schema)
+
                 schema.title = title
 
                 if schema == existing_schema:
@@ -199,30 +203,31 @@ class Flow(Node):
         self._refactor_spec_to_schemaref(node.spec)
                 
     def _refactor_spec_to_schemaref(self, spec: NodeSpec):
-        if spec.input_schema and (spec.input_schema.type == "object" or spec.input_schema.type == "array") :
+        if spec.input_schema and not isinstance(spec.input_schema, SchemaRef) and (spec.input_schema.type == "object" or spec.input_schema.type == "array") :
             if isinstance(spec.input_schema, ToolRequestBody):
                 spec.input_schema = self._add_schema_ref(JsonSchemaObject(type = spec.input_schema.type,
                                                                                 properties= spec.input_schema.properties,
                                                                                 required= spec.input_schema.required), 
                                                                 f"{spec.name}_input")
-        if spec.output_schema_object is not None and spec.output_schema_object.type == "object":
-            spec.output_schema = self._add_schema_ref(spec.output_schema_object, spec.output_schema_object.title)
-            spec.output_schema_object = None
-        elif spec.output_schema is not None:
-            if isinstance(spec.output_schema, ToolResponseBody):
-                if spec.output_schema.type == "object":
-                    json_obj = JsonSchemaObject(type = spec.output_schema.type,
-                            description=spec.output_schema.description,
-                            properties= spec.output_schema.properties,
-                            items = spec.output_schema.items,
-                            uniqueItems=spec.output_schema.uniqueItems,
-                            anyOf=spec.output_schema.anyOf,
-                            required= spec.output_schema.required)
-                    spec.output_schema = self._add_schema_ref(json_obj, f"{spec.name}_output")
-                elif spec.output_schema.type == "array":
-                    if hasattr(spec.output_schema, "items") and hasattr(spec.output_schema.items, "type") and spec.output_schema.items.type == "object":
-                        schema_ref = self._add_schema_ref(spec.output_schema.items)
-                        spec.output_schema.items = JsonSchemaObjectRef(ref=f"{schema_ref.ref}")
+        if not isinstance(spec.output_schema, SchemaRef):
+            if spec.output_schema_object is not None and spec.output_schema_object.type == "object":
+                spec.output_schema = self._add_schema_ref(spec.output_schema_object, spec.output_schema_object.title)
+                spec.output_schema_object = None
+            elif spec.output_schema is not None:
+                if isinstance(spec.output_schema, ToolResponseBody):
+                    if spec.output_schema.type == "object":
+                        json_obj = JsonSchemaObject(type = spec.output_schema.type,
+                                description=spec.output_schema.description,
+                                properties= spec.output_schema.properties,
+                                items = spec.output_schema.items,
+                                uniqueItems=spec.output_schema.uniqueItems,
+                                anyOf=spec.output_schema.anyOf,
+                                required= spec.output_schema.required)
+                        spec.output_schema = self._add_schema_ref(json_obj, f"{spec.name}_output")
+                    elif spec.output_schema.type == "array":
+                        if hasattr(spec.output_schema, "items") and hasattr(spec.output_schema.items, "type") and spec.output_schema.items.type == "object":
+                            schema_ref = self._add_schema_ref(spec.output_schema.items)
+                            spec.output_schema.items = JsonSchemaObjectRef(ref=f"{schema_ref.ref}")
 
     # def refactor_datamap_spec_to_schemaref(self, spec: FnDataMapSpec):
     #    '''TODO'''

{ibm_watsonx_orchestrate-1.9.0b2.dist-info → ibm_watsonx_orchestrate-1.10.0b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibm-watsonx-orchestrate
-Version: 1.9.0b2
+Version: 1.10.0b0
 Summary: IBM watsonx.orchestrate SDK
 Author-email: IBM <support@ibm.com>
 License: MIT License

{ibm_watsonx_orchestrate-1.9.0b2.dist-info → ibm_watsonx_orchestrate-1.10.0b0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-ibm_watsonx_orchestrate/__init__.py,sha256=qSsB-sI25lOiixDR8S9s8PpP3iB7TKKGjtr405WOdZI,427
+ibm_watsonx_orchestrate/__init__.py,sha256=CE0F2w_9jm2X8mCofA2JwrXdBnhedrW0zMrgrGnZNy8,429
 ibm_watsonx_orchestrate/agent_builder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ibm_watsonx_orchestrate/agent_builder/agents/__init__.py,sha256=lmZwaiWXD4Ea19nrMwZXaqCxFMG29xNS8vUoZtK3yI4,392
 ibm_watsonx_orchestrate/agent_builder/agents/agent.py,sha256=W0uya81fQPrYZFaO_tlsxBL56Bfpw0xrqdxQJhAZ6XI,983
 ibm_watsonx_orchestrate/agent_builder/agents/assistant_agent.py,sha256=NnWThJ2N8HUOD9IDL6ZhtTKyLMHSacJCpxDNityRmgY,1051
 ibm_watsonx_orchestrate/agent_builder/agents/external_agent.py,sha256=7HzEFjd7JiiRTgvA1RVA3M0-Mr42FTQnOtGMII5ufk0,1045
-ibm_watsonx_orchestrate/agent_builder/agents/types.py,sha256=kXbWWz4iHo-knQ5OZRZW7kc8rTwfOzPVn7iyndk5cDs,13013
+ibm_watsonx_orchestrate/agent_builder/agents/types.py,sha256=al_nz27cPqD1QLnamMgd8mkgUiATECaEptKttlkf0wU,13108
 ibm_watsonx_orchestrate/agent_builder/agents/webchat_customizations/__init__.py,sha256=5TXa8UqKUAlDo4hTbE5S9OPEkQhxXhPJHJC4pEe8U00,92
 ibm_watsonx_orchestrate/agent_builder/agents/webchat_customizations/prompts.py,sha256=jNVF_jgz1Dmt7-RxAceAS0XWXk_fx9h3sS_fGrvZT28,941
 ibm_watsonx_orchestrate/agent_builder/agents/webchat_customizations/welcome_content.py,sha256=U76wZrblSXx4qv7phcPYs3l8SiFzwZ5cJ74u8Y2iYhU,608
@@ -24,16 +24,18 @@ ibm_watsonx_orchestrate/agent_builder/tools/__init__.py,sha256=adkYX0wgB-RKFCUBw
 ibm_watsonx_orchestrate/agent_builder/tools/base_tool.py,sha256=0vwMIAyKyB8v1QmNrubLy8Al58g3qT78EUgrmOjegoI,1220
 ibm_watsonx_orchestrate/agent_builder/tools/flow_tool.py,sha256=DJWYVmIjw1O_cbzPpwU0a_vIZGvo0mj8UsjW9zkKMlA,2589
 ibm_watsonx_orchestrate/agent_builder/tools/openapi_tool.py,sha256=h9ma18GUQHt88UIakd6QZHic822bAXzYokh6sfqAMZk,19410
-ibm_watsonx_orchestrate/agent_builder/tools/python_tool.py,sha256=FDY-y9jy4bNy88i7JG85Zj_YrxnPfJPD0DjwvL9ITxc,12012
+ibm_watsonx_orchestrate/agent_builder/tools/python_tool.py,sha256=cdgu-v1oRR9RUbMNKEklOzO1z3nNZpDZPSMwnJEvuIY,12533
 ibm_watsonx_orchestrate/agent_builder/tools/types.py,sha256=m2t4uXNp0DVwVFzd0Jf_se8tz6V8FzM5fYgFs7AlvHU,8251
 ibm_watsonx_orchestrate/agent_builder/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ibm_watsonx_orchestrate/agent_builder/voice_configurations/__init__.py,sha256=W3-T8PH_KuONsCQPILQAvW2Nz25p7dp9AZbWHWGJXhA,37
+ibm_watsonx_orchestrate/agent_builder/voice_configurations/types.py,sha256=lSS1yiDzVAMkEdOwcI4_1DUuRnu_6oc8XupQtoE4Fvs,3989
 ibm_watsonx_orchestrate/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ibm_watsonx_orchestrate/cli/config.py,sha256=iXjDxymWhAmLSUu6eh7zJR20dYZDzbxcU5VoBdh3VIw,8318
 ibm_watsonx_orchestrate/cli/init_helper.py,sha256=qxnKdFcPtGsV_6RqP_IuLshRxgB004SxzDAkBTExA-4,1675
-ibm_watsonx_orchestrate/cli/main.py,sha256=eE71dfx-EdDYHymYDqXcTjyMXpX0b3cueXOxCI2YLLs,3119
+ibm_watsonx_orchestrate/cli/main.py,sha256=Jrp0d40-RAtpzsGnf45dpPxJi3d7snod5BCnFMh4foU,3384
 ibm_watsonx_orchestrate/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ibm_watsonx_orchestrate/cli/commands/agents/agents_command.py,sha256=Zif3bH3X7j5qf7MWGcr53mJ2oEKXNRHeg3ZHeoHTIqQ,8984
-ibm_watsonx_orchestrate/cli/commands/agents/agents_controller.py,sha256=gEsuG3Mbz6shuv8yB2C-dPcqM5mMXUAVO0YniNNOMk0,48379
+ibm_watsonx_orchestrate/cli/commands/agents/agents_command.py,sha256=sC3kRKO5ZvDGUSy5CBnS3C-qU6bG9kxG-u42KcpVYuQ,9574
+ibm_watsonx_orchestrate/cli/commands/agents/agents_controller.py,sha256=W1xeg4UQZ5fEudlvYfppw9PyfwTcQq-woWpHPZorUPc,55704
 ibm_watsonx_orchestrate/cli/commands/channels/channels_command.py,sha256=fVIFhPUTPdxsxIE10nWL-W5wvBR-BS8V8D6r__J8R98,822
 ibm_watsonx_orchestrate/cli/commands/channels/channels_controller.py,sha256=WjQxwJujvo28SsWgfJSXIpkcgniKcskJ2arL4MOz0Ys,455
 ibm_watsonx_orchestrate/cli/commands/channels/types.py,sha256=hMFvWPr7tAmDrhBqtzfkCsrubX3lsU6lapTSOFsUbHM,475
@@ -51,12 +53,12 @@ ibm_watsonx_orchestrate/cli/commands/environment/types.py,sha256=X6jEnyBdxakromA
 ibm_watsonx_orchestrate/cli/commands/evaluations/evaluations_command.py,sha256=nOVxeZSTp1bfV_l_06B6x6wfNeusNAr5KImJYkwGWx8,14298
 ibm_watsonx_orchestrate/cli/commands/evaluations/evaluations_controller.py,sha256=dZEAD0rIS9DQjWD2-i6367RjNd2PWB3Fm_DDk25toBg,7855
 ibm_watsonx_orchestrate/cli/commands/knowledge_bases/knowledge_bases_command.py,sha256=hOzRcGVoqq7dTc4bSregKxH-kYbrVqaFdhBLawqnRNo,2668
-ibm_watsonx_orchestrate/cli/commands/knowledge_bases/knowledge_bases_controller.py,sha256=M19rRMFEEcAarPVw4fOr3S94Se1ZEo4hD7sCUr0xYTI,10115
+ibm_watsonx_orchestrate/cli/commands/knowledge_bases/knowledge_bases_controller.py,sha256=AyGc2JudpHaSf0ktHSVRkPVsaejWL8KH7Dv0XgEGZ1U,10531
 ibm_watsonx_orchestrate/cli/commands/login/login_command.py,sha256=xArMiojoozg7Exn6HTpbTcjDO2idZRA-y0WV-_Ic1Sk,651
 ibm_watsonx_orchestrate/cli/commands/models/model_provider_mapper.py,sha256=mbvBR5o9M7W6OpTZyd6TtSEOIXq07dPYz4hv5zDrsd0,8129
 ibm_watsonx_orchestrate/cli/commands/models/models_command.py,sha256=PW-PIM5Nq0qdCopWjANGBWEuEoA3NLTFThYrN8ggGCI,6425
 ibm_watsonx_orchestrate/cli/commands/models/models_controller.py,sha256=eZSYQUg9TL_-8lgcPVpKIx7MtOE7K_NCvZW9Y9YsFA0,18466
-ibm_watsonx_orchestrate/cli/commands/server/server_command.py,sha256=9VM9i2g54UwK0wsQ7z1m3KSDItoAslSk693YKGXPq0s,43309
+ibm_watsonx_orchestrate/cli/commands/server/server_command.py,sha256=VhNfBPVXtTjMt-wKLtlXhWu5YB9TQ7BTnBrxWUDZdU4,43636
 ibm_watsonx_orchestrate/cli/commands/server/types.py,sha256=UCrgGErbSVBnOzesfjrIii4tTCuVfWemYz5AKGZX0oA,4213
 ibm_watsonx_orchestrate/cli/commands/settings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ibm_watsonx_orchestrate/cli/commands/settings/settings_command.py,sha256=CzXRkd-97jXyS6LtaaNtMah-aZu0919dYl-mDwzGThc,344
@@ -67,8 +69,10 @@ ibm_watsonx_orchestrate/cli/commands/settings/observability/langfuse/langfuse_co
 ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_command.py,sha256=KI96Yexq4ZkM-VxcW88oMszjnOxbdU7quSxFtvf_ry4,4367
 ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_controller.py,sha256=3Jykp5-DzMM_At8kYJto171V6LesaqKdsk2nfg1TRpk,11949
 ibm_watsonx_orchestrate/cli/commands/tools/tools_command.py,sha256=Cuo1ZvlfsymojqbadCqdwwS0HUjaWpe2XQrV70g61_s,3943
-ibm_watsonx_orchestrate/cli/commands/tools/tools_controller.py,sha256=4VnV_rm7uXA7gtAfmqdw7igb5tkVGyhcsoni21jMDFA,40407
+ibm_watsonx_orchestrate/cli/commands/tools/tools_controller.py,sha256=_iXQx_Ycno4bpgI0HuJNsf2yYNP_8o6AOCUlBavBHEE,40720
 ibm_watsonx_orchestrate/cli/commands/tools/types.py,sha256=_md0GEa_cTH17NO_moWDY_LNdFvyEFQ1UVB9_FltYiA,173
+ibm_watsonx_orchestrate/cli/commands/voice_configurations/voice_configurations_command.py,sha256=q4KHWQ-LZbp31e2ytihX1OuyAPS4-nRinmc-eMXC0l0,1783
+ibm_watsonx_orchestrate/cli/commands/voice_configurations/voice_configurations_controller.py,sha256=JbAc_CY0woHY8u7qrnOcb9O2FgECzkzeMirxFhRoep8,5884
 ibm_watsonx_orchestrate/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ibm_watsonx_orchestrate/client/base_api_client.py,sha256=cSbQb7-K9KoMeFLEIiYGho4cQqf8TcPyYklju9X4cC4,5214
 ibm_watsonx_orchestrate/client/base_service_instance.py,sha256=sM_r7bln9BpgEOhaJMdFI9-je3T7GLQxLduk-in0oRY,235
@@ -78,7 +82,7 @@ ibm_watsonx_orchestrate/client/credentials.py,sha256=gDVeeQZDdbbjJiO1EI61yx2oRgT
 ibm_watsonx_orchestrate/client/local_service_instance.py,sha256=dt7vfLnjgt7mT8wSq8SJZndNTwsPzhb0XDhcnPUPFpU,3524
 ibm_watsonx_orchestrate/client/service_instance.py,sha256=fp3Lc4yQf4zTkxVS5WnIAkrHT0xG_a5i44qcLeQkaa4,6600
 ibm_watsonx_orchestrate/client/utils.py,sha256=MUw11r0_wYv3RdF6-1BmSxcwYNF6q2_Urte7tMYTKVA,5836
-ibm_watsonx_orchestrate/client/agents/agent_client.py,sha256=v1ZqXKj3p5JeJyOLpV84UUI2LY8XPjW1ejo5yzkeiMQ,4708
+ibm_watsonx_orchestrate/client/agents/agent_client.py,sha256=ObAoh5g4zvB1mZiA6xotvs4b1FGE1r92kkb2C7juGn8,6890
 ibm_watsonx_orchestrate/client/agents/assistant_agent_client.py,sha256=1JQN0E4T_uz5V0LM-LD1ahNu2KCeFBjXAr8WCiP9mkE,1745
 ibm_watsonx_orchestrate/client/agents/external_agent_client.py,sha256=iQ44XBdC4rYfS-zFn4St1xC5y5gf5SNqKHzMNQcFDZc,1808
 ibm_watsonx_orchestrate/client/analytics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -96,8 +100,9 @@ ibm_watsonx_orchestrate/client/models/models_client.py,sha256=ZvP3iPgUFw_SXp41kJ
 ibm_watsonx_orchestrate/client/toolkit/toolkit_client.py,sha256=TLFNS39EeBD_t4Y-rX9sGp4sWBDr--mE5qVtHq8Q2hk,3121
 ibm_watsonx_orchestrate/client/tools/tempus_client.py,sha256=24fKDZUOVHBW-Vj4mubnpnUmab5LgGn8u5hOVyJaozI,1804
 ibm_watsonx_orchestrate/client/tools/tool_client.py,sha256=d3i3alVwa0TCN72w9sWOrM20GCbNmnpTnqEOJVbBIFM,1994
-ibm_watsonx_orchestrate/docker/compose-lite.yml,sha256=Mg8XqWLTxQS7Xl_tP32MGvkvEFyGiwEnug5FWyVjV7g,43616
-ibm_watsonx_orchestrate/docker/default.env,sha256=wdBu50CfT3wg9FSJ9ekW6_OGtQVNGk4nrdfOgR_6Hk0,6128
+ibm_watsonx_orchestrate/client/voice_configurations/voice_configurations_client.py,sha256=M5xIPLiVNpP-zxQw8CTNT9AiBjeXXmJiNaE142e2A3E,2682
+ibm_watsonx_orchestrate/docker/compose-lite.yml,sha256=LdAwhDdslZ5SHxV5CGRjJliEeAfuk6N8a_Xv-4QWSNc,44133
+ibm_watsonx_orchestrate/docker/default.env,sha256=13lliXku5OQsZo2vRPEv6ev0k6GpVRErRQKWNY_o6IY,6234
 ibm_watsonx_orchestrate/docker/proxy-config-single.yaml,sha256=WEbK4ENFuTCYhzRu_QblWp1_GMARgZnx5vReQafkIG8,308
 ibm_watsonx_orchestrate/docker/start-up.sh,sha256=LTtwHp0AidVgjohis2LXGvZnkFQStOiUAxgGABOyeUI,1811
 ibm_watsonx_orchestrate/docker/sdk/ibm_watsonx_orchestrate-0.6.0-py3-none-any.whl,sha256=Hi3-owh5OM0Jz2ihX9nLoojnr7Ky1TV-GelyqLcewLE,2047417
@@ -112,7 +117,7 @@ ibm_watsonx_orchestrate/flow_builder/flows/__init__.py,sha256=jbCklY7l08KG8cbFih
 ibm_watsonx_orchestrate/flow_builder/flows/constants.py,sha256=-TGneZyjA4YiAtJJK7OmmjDHYQC4mw2e98MPAZqiB50,324
 ibm_watsonx_orchestrate/flow_builder/flows/decorators.py,sha256=lr4qSWq5PWqlGFf4fzUQZCVQDHBYflrYwZ24S89Aq80,2794
 ibm_watsonx_orchestrate/flow_builder/flows/events.py,sha256=VyaBm0sADwr15LWfKbcBQS1M80NKqzYDj3UlW3OpOf4,2984
-ibm_watsonx_orchestrate/flow_builder/flows/flow.py,sha256=uAk_uS2i1zH3toJQw7I_5zaSPVOdvAyEitGdM0rxrJI,56949
+ibm_watsonx_orchestrate/flow_builder/flows/flow.py,sha256=WPAdXML0o9RuHZE0ajBBOrorS6YmJd8RhV3-FMbDifM,57304
 ibm_watsonx_orchestrate/run/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ibm_watsonx_orchestrate/run/connections.py,sha256=K-65GXPA8GEsVmRdPfMe_LB2G9RfXQUr95wvRUOhkS4,1828
 ibm_watsonx_orchestrate/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -121,8 +126,8 @@ ibm_watsonx_orchestrate/utils/utils.py,sha256=U7z_2iASoFiZ2zM0a_2Mc2Y-P5oOT7hOwu
 ibm_watsonx_orchestrate/utils/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ibm_watsonx_orchestrate/utils/logging/logger.py,sha256=FzeGnidXAjC7yHrvIaj4KZPeaBBSCniZFlwgr5yV3oA,1037
 ibm_watsonx_orchestrate/utils/logging/logging.yaml,sha256=9_TKfuFr1barnOKP0fZT5D6MhddiwsXVTFjtRbcOO5w,314
-ibm_watsonx_orchestrate-1.9.0b2.dist-info/METADATA,sha256=vUmVmbH5irCvOWWPEcc9ckYadyPb1xtRTbGvAaq8K5o,1362
-ibm_watsonx_orchestrate-1.9.0b2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ibm_watsonx_orchestrate-1.9.0b2.dist-info/entry_points.txt,sha256=SfIT02-Jen5e99OcLhzbcM9Bdyf8SGVOCtnSplgZdQI,69
-ibm_watsonx_orchestrate-1.9.0b2.dist-info/licenses/LICENSE,sha256=Shgxx7hTdCOkiVRmfGgp_1ISISrwQD7m2f0y8Hsapl4,1083
-ibm_watsonx_orchestrate-1.9.0b2.dist-info/RECORD,,
+ibm_watsonx_orchestrate-1.10.0b0.dist-info/METADATA,sha256=j9LQ4nwtXYKwZJGT48LSfws9sC84DZ9tHXHki4E-a9s,1363
+ibm_watsonx_orchestrate-1.10.0b0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ibm_watsonx_orchestrate-1.10.0b0.dist-info/entry_points.txt,sha256=SfIT02-Jen5e99OcLhzbcM9Bdyf8SGVOCtnSplgZdQI,69
+ibm_watsonx_orchestrate-1.10.0b0.dist-info/licenses/LICENSE,sha256=Shgxx7hTdCOkiVRmfGgp_1ISISrwQD7m2f0y8Hsapl4,1083
+ibm_watsonx_orchestrate-1.10.0b0.dist-info/RECORD,,