ibm-watsonx-orchestrate 1.9.0.dev0__py3-none-any.whl → 1.10.0__py3-none-any.whl

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

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/connections/connections_client.py

@@ -19,7 +19,7 @@ class FetchConfigAuthTypes(str, Enum):
     API_KEY_AUTH = ConnectionType.API_KEY_AUTH.value
     OAUTH2_AUTH_CODE = ConnectionType.OAUTH2_AUTH_CODE.value
     OAUTH2_IMPLICIT = 'oauth2_implicit'
-    OAUTH2_PASSWORD = 'oauth2_password'
+    OAUTH2_PASSWORD = ConnectionType.OAUTH2_PASSWORD.value
     OAUTH2_CLIENT_CREDS = ConnectionType.OAUTH2_CLIENT_CREDS.value
     OAUTH_ON_BEHALF_OF_FLOW = ConnectionType.OAUTH_ON_BEHALF_OF_FLOW.value
     KEY_VALUE = ConnectionType.KEY_VALUE.value
@@ -50,7 +50,7 @@ class GetConfigResponse(BaseModel):
 class GetConnectionResponse(BaseModel):
     connection_id: str = None
     app_id: str = None
-    tenant_id: str = None
+    tenant_id: Optional[str] = None
 
 
 
@@ -141,7 +141,8 @@ class ConnectionsClient(BaseAPIClient):
             else:
                 return self._get(f"/connections/applications/runtime_credentials?app_id={app_id}&env={env}")
         except ClientAPIException as e:
-            if e.response.status_code == 404:
+            # Returns 400 when app creds exist but runtime cred don't yet exist
+            if e.response.status_code == 404 or e.response.status_code == 400:
                 return None
             raise e
 

ibm_watsonx_orchestrate/client/knowledge_bases/knowledge_base_client.py

@@ -15,10 +15,10 @@ class KnowledgeBaseClient(BaseAPIClient):
         self.base_endpoint = "/orchestrate/knowledge-bases" if is_local_dev(self.base_url) else "/knowledge-bases"
 
     def create(self, payload: dict) -> dict:
-        return self._post_form_data(f"{self.base_endpoint}/documents", data={ "knowledge_base" : json.dumps(payload) })
+        return self._post_form_data(f"{self.base_endpoint}/documents", data=payload)
     
     def create_built_in(self, payload: dict, files: list) -> dict:
-        return self._post_form_data(f"{self.base_endpoint}/documents", data={ "knowledge_base" : json.dumps(payload) }, files=files)
+        return self._post_form_data(f"{self.base_endpoint}/documents", data=payload, files=files)
 
     def get(self) -> dict:
         return self._get(self.base_endpoint)
@@ -38,10 +38,10 @@ class KnowledgeBaseClient(BaseAPIClient):
         return self._get(f"{self.base_endpoint}/{knowledge_base_id}/status")
 
     def update(self, knowledge_base_id: str, payload: dict) -> dict:
-        return self._patch_form_data(f"{self.base_endpoint}/{knowledge_base_id}/documents", data={ "knowledge_base" : json.dumps(payload) })
+        return self._patch_form_data(f"{self.base_endpoint}/{knowledge_base_id}/documents", data=payload)
     
     def update_with_documents(self, knowledge_base_id: str, payload: dict, files: list) -> dict:
-        return self._patch_form_data(f"{self.base_endpoint}/{knowledge_base_id}/documents", data={ "knowledge_base" : json.dumps(payload) }, files=files)
+        return self._patch_form_data(f"{self.base_endpoint}/{knowledge_base_id}/documents", data=payload, files=files)
 
     def delete(self, knowledge_base_id: str,) -> dict:
         return self._delete(f"{self.base_endpoint}/{knowledge_base_id}")

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