ibm-watsonx-orchestrate 1.6.3__py3-none-any.whl → 1.6.4__py3-none-any.whl

ibm_watsonx_orchestrate/__init__.py

@@ -5,7 +5,8 @@
 
 pkg_name = "ibm-watsonx-orchestrate"
 
-__version__ = "1.6.3"
+__version__ = "1.6.4"
+
 
 
 

ibm_watsonx_orchestrate/agent_builder/agents/agent.py

@@ -1,6 +1,7 @@
 import json
 from ibm_watsonx_orchestrate.utils.utils import yaml_safe_load
 from .types import AgentSpec
+from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 
 
 class Agent(AgentSpec):
@@ -13,10 +14,9 @@ class Agent(AgentSpec):
             elif file.endswith('.json'):
                 content = json.load(f)
             else:
-                raise ValueError('file must end in .json, .yaml, or .yml')
-            
+                raise BadRequest('file must end in .json, .yaml, or .yml')
             if not content.get("spec_version"):
-                raise ValueError(f"Field 'spec_version' not provided. Please ensure provided spec conforms to a valid spec format")
+                raise BadRequest(f"Field 'spec_version' not provided. Please ensure provided spec conforms to a valid spec format")
             agent = Agent.model_validate(content)
 
         return agent

ibm_watsonx_orchestrate/agent_builder/agents/assistant_agent.py

@@ -1,6 +1,7 @@
 import json
 from ibm_watsonx_orchestrate.utils.utils import yaml_safe_load
 from .types import AssistantAgentSpec
+from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 
 
 class AssistantAgent(AssistantAgentSpec):
@@ -13,10 +14,10 @@ class AssistantAgent(AssistantAgentSpec):
             elif file.endswith('.json'):
                 content = json.load(f)
             else:
-                raise ValueError('file must end in .json, .yaml, or .yml')
+                raise BadRequest('file must end in .json, .yaml, or .yml')
             
             if not content.get("spec_version"):
-                raise ValueError(f"Field 'spec_version' not provided. Please ensure provided spec conforms to a valid spec format")
+                raise BadRequest(f"Field 'spec_version' not provided. Please ensure provided spec conforms to a valid spec format")
             agent = AssistantAgent.model_validate(content)
 
         return agent

ibm_watsonx_orchestrate/agent_builder/agents/external_agent.py

@@ -1,6 +1,7 @@
 import json
 from ibm_watsonx_orchestrate.utils.utils import yaml_safe_load
 from .types import ExternalAgentSpec
+from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 
 
 class ExternalAgent(ExternalAgentSpec):
@@ -13,10 +14,10 @@ class ExternalAgent(ExternalAgentSpec):
             elif file.endswith('.json'):
                 content = json.load(f)
             else:
-                raise ValueError('file must end in .json, .yaml, or .yml')
+                raise BadRequest('file must end in .json, .yaml, or .yml')
             
             if not content.get("spec_version"):
-                raise ValueError(f"Field 'spec_version' not provided. Please ensure provided spec conforms to a valid spec format")
+                raise BadRequest(f"Field 'spec_version' not provided. Please ensure provided spec conforms to a valid spec format")
             agent = ExternalAgent.model_validate(content)
 
         return agent

ibm_watsonx_orchestrate/agent_builder/agents/types.py

@@ -9,21 +9,44 @@ from ibm_watsonx_orchestrate.agent_builder.knowledge_bases.knowledge_base import
 from ibm_watsonx_orchestrate.agent_builder.agents.webchat_customizations import StarterPrompts, WelcomeContent
 from pydantic import Field, AliasChoices
 from typing import Annotated
+from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 
 from ibm_watsonx_orchestrate.agent_builder.tools.types import JsonSchemaObject
 
 # TO-DO: this is just a placeholder. Will update this later to align with backend
-DEFAULT_LLM = "watsonx/meta-llama/llama-3-1-70b-instruct"
+DEFAULT_LLM = "watsonx/meta-llama/llama-3-2-90b-vision-instruct"
+
+# Handles yaml formatting for multiline strings to improve readability
+def str_presenter(dumper, data):
+    if len(data.splitlines()) > 1:  # check for multiline string
+        data = "\n".join([line.rstrip() for line in data.splitlines()])
+        return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='|')
+    return dumper.represent_scalar('tag:yaml.org,2002:str', data)
+
+yaml.add_representer(str, str_presenter)
+yaml.representer.SafeRepresenter.add_representer(str, str_presenter) # to use with safe_dum
 
 class SpecVersion(str, Enum):
     V1 = "v1"
 
+    def __str__(self):
+        return self.value 
+
+    def __repr__(self):
+        return repr(self.value)
+
 
 class AgentKind(str, Enum):
     NATIVE = "native"
     EXTERNAL = "external"
     ASSISTANT = "assistant"
 
+    def __str__(self):
+        return self.value 
+
+    def __repr__(self):
+        return repr(self.value)
+
 class ExternalAgentAuthScheme(str, Enum):
     BEARER_TOKEN = 'BEARER_TOKEN'
     API_KEY = "API_KEY"
@@ -63,7 +86,7 @@ class BaseAgentSpec(BaseModel):
             elif file.endswith('.json'):
                 json.dump(dumped, f, indent=2)
             else:
-                raise ValueError('file must end in .json, .yaml, or .yml')
+                raise BadRequest('file must end in .json, .yaml, or .yml')
 
     def dumps_spec(self) -> str:
         dumped = self.model_dump(mode='json', exclude_none=True)
@@ -87,6 +110,12 @@ class AgentStyle(str, Enum):
     REACT = "react"
     PLANNER = "planner"
 
+    def __str__(self):
+        return self.value 
+
+    def __repr__(self):
+        return repr(self.value)
+
 class AgentGuideline(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -136,7 +165,7 @@ class AgentSpec(BaseAgentSpec):
     @model_validator(mode="after")
     def validate_kind(self):
         if self.kind != AgentKind.NATIVE:
-            raise ValueError(f"The specified kind '{self.kind}' cannot be used to create a native agent.")
+            raise BadRequest(f"The specified kind '{self.kind}' cannot be used to create a native agent.")
         return self
 
 def validate_agent_fields(values: dict) -> dict:
@@ -144,13 +173,13 @@ def validate_agent_fields(values: dict) -> dict:
     for field in ["id", "name", "kind", "description", "collaborators", "tools", "knowledge_base"]:
         value = values.get(field)
         if value and not str(value).strip():
-            raise ValueError(f"{field} cannot be empty or just whitespace")
+            raise BadRequest(f"{field} cannot be empty or just whitespace")
     
     name = values.get("name")
     collaborators = values.get("collaborators", [])  if values.get("collaborators", []) else []
     for collaborator in collaborators:
         if collaborator == name:
-            raise ValueError(f"Circular reference detected. The agent '{name}' cannot contain itself as a collaborator")
+            raise BadRequest(f"Circular reference detected. The agent '{name}' cannot contain itself as a collaborator")
 
     if values.get("style") == AgentStyle.PLANNER:
         if values.get("custom_join_tool") and values.get("structured_output"):
@@ -197,7 +226,7 @@ class ExternalAgentSpec(BaseAgentSpec):
     @model_validator(mode="after")
     def validate_kind_for_external(self):
         if self.kind != AgentKind.EXTERNAL:
-            raise ValueError(f"The specified kind '{self.kind}' cannot be used to create an external agent.")
+            raise BadRequest(f"The specified kind '{self.kind}' cannot be used to create an external agent.")
         return self
 
 def validate_external_agent_fields(values: dict) -> dict:
@@ -205,7 +234,7 @@ def validate_external_agent_fields(values: dict) -> dict:
     for field in ["name", "kind", "description", "title", "tags", "api_url", "chat_params", "nickname", "app_id"]:
         value = values.get(field)
         if value and not str(value).strip():
-            raise ValueError(f"{field} cannot be empty or just whitespace")
+            raise BadRequest(f"{field} cannot be empty or just whitespace")
 
     context_variables = values.get("context_variables")
     if context_variables is not None:
@@ -250,7 +279,7 @@ class AssistantAgentSpec(BaseAgentSpec):
     @model_validator(mode="after")
     def validate_kind_for_external(self):
         if self.kind != AgentKind.ASSISTANT:
-            raise ValueError(f"The specified kind '{self.kind}' cannot be used to create an assistant agent.")
+            raise BadRequest(f"The specified kind '{self.kind}' cannot be used to create an assistant agent.")
         return self
 
 def validate_assistant_agent_fields(values: dict) -> dict:
@@ -258,7 +287,7 @@ def validate_assistant_agent_fields(values: dict) -> dict:
     for field in ["name", "kind", "description", "title", "tags", "nickname", "app_id"]:
         value = values.get(field)
         if value and not str(value).strip():
-            raise ValueError(f"{field} cannot be empty or just whitespace")
+            raise BadRequest(f"{field} cannot be empty or just whitespace")
 
     # Validate context_variables if provided
     context_variables = values.get("context_variables")

ibm_watsonx_orchestrate/agent_builder/connections/connections.py

@@ -14,6 +14,7 @@ from ibm_watsonx_orchestrate.agent_builder.connections.types import (
 )
 
 from ibm_watsonx_orchestrate.utils.utils import sanatize_app_id
+from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 
 logger = logging.getLogger(__name__)
 
@@ -61,7 +62,7 @@ def _clean_env_vars(vars: dict[str:str], requirements: List[str], app_id: str) -
         missing_requirements_str = ", ".join(missing_requirements)
         message = f"Missing requirement environment variables '{missing_requirements_str}' for connection '{app_id}'"
         logger.error(message)
-        raise ValueError(message)
+        raise BadRequest(message)
     
     return required_env_vars
 
@@ -114,7 +115,7 @@ def get_connection_type(app_id: str) -> ConnectionSecurityScheme:
     if not expected_schema:
         message = f"No credentials found for connections '{app_id}'"
         logger.error(message)
-        raise ValueError(message)
+        raise BadRequest(message)
 
     auth_types = {e.value for e in ConnectionSecurityScheme}
     if expected_schema not in auth_types:
@@ -132,6 +133,6 @@ def get_application_connection_credentials(type: ConnectionType, app_id: str) ->
     if not _validate_schema_type(requested_type=requested_schema, expected_type=expected_schema):
         message = f"The requested type '{requested_schema}' does not match the type '{expected_schema}' for the connection '{app_id}'"
         logger.error(message)
-        raise ValueError(message)
+        raise BadRequest(message)
 
     return _get_credentials_model(connection_type=requested_schema, app_id=sanitized_app_id)

ibm_watsonx_orchestrate/agent_builder/connections/types.py

@@ -75,6 +75,16 @@ class ConnectionType(str, Enum):
 
     def __repr__(self):
         return repr(self.value)
+    
+class ConnectionSendVia(str,Enum):
+    HEADER = 'header'
+    BODY = 'body'
+
+    def __str__(self):
+        return self.value
+    
+    def __repr__(self):
+        return repr(self.value)
 
 OAUTH_CONNECTION_TYPES = {
     ConnectionType.OAUTH2_AUTH_CODE,
@@ -177,7 +187,7 @@ class OAuth2AuthCodeCredentials(BaseModel):
     client_secret: str
     token_url: str
     authorization_url: str
-    scopes : Optional[List[str]] = None
+    scope : Optional[str] = None
 
 # class OAuth2ImplicitCredentials(BaseModel):
 #     client_id: str
@@ -193,7 +203,9 @@ class OAuth2ClientCredentials(BaseModel):
     client_id: str
     client_secret: str
     token_url: str
-    scopes : Optional[List[str]] = None
+    scope : Optional[str] = None
+    send_via: ConnectionSendVia = ConnectionSendVia.HEADER
+    grant_type: str = "client_credentials"
 
 class OAuthOnBehalfOfCredentials(BaseModel):
     client_id: str

ibm_watsonx_orchestrate/agent_builder/knowledge_bases/knowledge_base_requests.py

@@ -1,7 +1,6 @@
 import json
 from ibm_watsonx_orchestrate.utils.utils import yaml_safe_load
-from .types import KnowledgeBaseSpec, PatchKnowledgeBase, KnowledgeBaseKind
-
+from .types import KnowledgeBaseSpec
 
 class KnowledgeBaseCreateRequest(KnowledgeBaseSpec):
 
@@ -21,23 +20,3 @@ class KnowledgeBaseCreateRequest(KnowledgeBaseSpec):
             knowledge_base = KnowledgeBaseSpec.model_validate(content)
 
         return knowledge_base
-    
-
-class KnowledgeBaseUpdateRequest(PatchKnowledgeBase):
-
-    @staticmethod
-    def from_spec(file: str) -> 'PatchKnowledgeBase':
-        with open(file, 'r') as f:
-            if file.endswith('.yaml') or file.endswith('.yml'):
-                content = yaml_safe_load(f)
-            elif file.endswith('.json'):
-                content = json.load(f)
-            else:
-                raise ValueError('file must end in .json, .yaml, or .yml')
-            
-            if not content.get("spec_version"):
-                raise ValueError(f"Field 'spec_version' not provided. Please ensure provided spec conforms to a valid spec format")
-            
-            patch = PatchKnowledgeBase.model_validate(content)
-
-        return patch

ibm_watsonx_orchestrate/agent_builder/knowledge_bases/types.py

@@ -3,7 +3,7 @@ from datetime import datetime
 from uuid import UUID
 from enum import Enum
 
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel
 
 class SpecVersion(str, Enum):
     V1 = "v1"
@@ -219,22 +219,6 @@ class KnowledgeBaseBuiltInVectorIndexConfig(BaseModel):
     chunk_overlap: Optional[int] = None
     limit: Optional[int] = None
     
-class PatchKnowledgeBase(BaseModel):
-    """request payload schema"""
-    description: Optional[str] = None
-    documents: list[str] = None
-    conversational_search_tool: Optional[ConversationalSearchConfig] = None  
-    prioritize_built_in_index: Optional[bool] = None
-    representation: Optional[KnowledgeBaseRepresentation] = None
-
-    @model_validator(mode="after")
-    def validate_fields(self):
-        if self.documents and self.conversational_search_tool and self.conversational_search_tool.index_config:
-            raise ValueError("Must not provide both \"documents\" or \"conversational_search_tool.index_config\"")
-        if self.conversational_search_tool and self.conversational_search_tool.index_config and len(self.conversational_search_tool.index_config) != 1:
-            raise ValueError(f"Must provide exactly one conversational_search_tool.index_config. Provided {len(self.conversational_search_tool.index_config)}.")
-        return self
-    
 class KnowledgeBaseSpec(BaseModel):
     """Schema for a complete knowledge-base."""
     spec_version: SpecVersion = None

ibm_watsonx_orchestrate/agent_builder/tools/base_tool.py

@@ -4,6 +4,7 @@ import yaml
 
 from .types import ToolSpec
 
+from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 
 class BaseTool:
     __tool_spec__: ToolSpec
@@ -22,7 +23,7 @@ class BaseTool:
             elif file.endswith('.json'):
                 json.dump(dumped, f, indent=2)
             else:
-                raise ValueError('file must end in .json, .yaml, or .yml')
+                raise BadRequest('file must end in .json, .yaml, or .yml')
 
     def dumps_spec(self) -> str:
         dumped = self.__tool_spec__.model_dump(mode='json', exclude_unset=True, exclude_none=True, by_alias=True)

ibm_watsonx_orchestrate/agent_builder/tools/openapi_tool.py

@@ -3,6 +3,7 @@ import json
 import os.path
 import logging
 from typing import Dict, Any, List
+from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 
 import yaml
 import yaml.constructor
@@ -13,7 +14,7 @@ from ibm_watsonx_orchestrate.utils.utils import yaml_safe_load
 from .types import ToolSpec
 from .base_tool import BaseTool
 from .types import HTTP_METHOD, ToolPermission, ToolRequestBody, ToolResponseBody, \
-    OpenApiToolBinding, \
+    OpenApiToolBinding, AcknowledgementBinding, \
     JsonSchemaObject, ToolBinding, OpenApiSecurityScheme, CallbackBinding
 
 import json
@@ -40,7 +41,7 @@ class OpenAPITool(BaseTool):
         BaseTool.__init__(self, spec=spec)
 
         if self.__tool_spec__.binding.openapi is None:
-            raise ValueError('Missing openapi binding')
+            raise BadRequest('Missing openapi binding')
 
     async def __call__(self, **kwargs):
         raise RuntimeError('OpenAPI Tools are only available when deployed onto watson orchestrate or the watson '
@@ -54,10 +55,10 @@ class OpenAPITool(BaseTool):
             elif file.endswith('.json'):
                 spec = ToolSpec.model_validate(json.load(f))
             else:
-                raise ValueError('file must end in .json, .yaml, or .yml')
+                raise BadRequest('file must end in .json, .yaml, or .yml')
 
         if spec.binding.openapi is None or spec.binding.openapi is None:
-            raise ValueError('failed to load python tool as the tool had no openapi binding')
+            raise BadRequest('failed to load python tool as the tool had no openapi binding')
 
         return OpenAPITool(spec=spec)
 
@@ -108,11 +109,11 @@ def create_openapi_json_tool(
     paths = openapi_contents.get('paths', {})
     route = paths.get(http_path)
     if route is None:
-        raise ValueError(f"Path {http_path} not found in paths. Available endpoints are: {list(paths.keys())}")
+        raise BadRequest(f"Path {http_path} not found in paths. Available endpoints are: {list(paths.keys())}")
 
     route_spec = route.get(http_method.lower(), route.get(http_method.upper()))
     if route_spec is None:
-        raise ValueError(
+        raise BadRequest(
             f"Path {http_path} did not have an http_method {http_method}. Available methods are {list(route.keys())}")
 
     operation_id = re.sub( r'(\W|_)+', '_', route_spec.get('operationId') ) \
@@ -121,12 +122,12 @@ def create_openapi_json_tool(
     spec_name = name or operation_id
     spec_permission = permission or _action_to_perm(route_spec.get('x-ibm-operation', {}).get('action'))
     if spec_name is None:
-        raise ValueError(
-            f"No name provided for tool. {http_method}: {http_path} did not specify an operationId, and no name was provided")
+        raise BadRequest(
+            f"Failed to import tool from endpoint {http_method}: {http_path} as no operationId was provided. An operationId must be provided to generate the name of the tool.")
 
     spec_description = description or route_spec.get('description')
     if spec_description is None:
-        raise ValueError(
+        raise BadRequest(
             f"No description provided for tool. {http_method}: {http_path} did not specify a description field, and no description was provided")
 
     spec = ToolSpec(
@@ -199,42 +200,89 @@ def create_openapi_json_tool(
     for needed_security in route_spec.get('security', []) + openapi_spec.get('security', []):
         name = next(iter(needed_security.keys()), None)
         if name is None or name not in security_schemes_map:
-            raise ValueError(f"Invalid openapi spec, {HTTP_METHOD} {http_path} asks for a security scheme of {name}, "
+            raise BadRequest(f"Invalid openapi spec, {HTTP_METHOD} {http_path} asks for a security scheme of {name}, "
                              f"but no such security scheme was configured in the .security section of the spec")
 
         security.append(security_schemes_map[name])
 
     # If it's an async tool, add callback binding
     if spec.is_async:
-
-
         callbacks = route_spec.get('callbacks', {})
         callback_name = next(iter(callbacks.keys()))
         callback_spec = callbacks[callback_name]
         callback_path = next(iter(callback_spec.keys()))
         callback_method = next(iter(callback_spec[callback_path].keys()))
+        callback_operation = callback_spec[callback_path][callback_method]
         
-        # Phase 1: Create a separate input schema for callback that excludes callbackUrl
-        # Note: Currently assuming the callback URL parameter will be named 'callbackUrl' in the OpenAPI spec
-        # Future phases will handle other naming conventions
+        # Extract callback input schema from the callback requestBody
         callback_input_schema = ToolRequestBody(
+            type='object',
+            properties={},
+            required=[]
+        )
+        
+        # Handle callback parameters (query, path, header params)
+        callback_parameters = callback_operation.get('parameters') or []
+        for parameter in callback_parameters:
+            name = f"{parameter['in']}_{parameter['name']}"
+            if parameter.get('required'):
+                callback_input_schema.required.append(name)
+            parameter['schema']['title'] = parameter['name']
+            parameter['schema']['description'] = parameter.get('description', None)
+            callback_input_schema.properties[name] = JsonSchemaObject.model_validate(parameter['schema'])
+            callback_input_schema.properties[name].in_field = parameter['in']
+            callback_input_schema.properties[name].aliasName = parameter['name']
+        
+        # Handle callback request body
+        callback_request_body_params = callback_operation.get('requestBody', {}).get('content', {}).get(http_response_content_type, {}).get('schema', None)
+        if callback_request_body_params is not None:
+            callback_input_schema.required.append('__requestBody__')
+            callback_request_body_params = copy.deepcopy(callback_request_body_params)
+            callback_request_body_params['in'] = 'body'
+            if callback_request_body_params.get('title') is None:
+                callback_request_body_params['title'] = 'CallbackRequestBody'
+            if callback_request_body_params.get('description') is None:
+                callback_request_body_params['description'] = 'The callback request body used for this async operation.'
+            
+            callback_input_schema.properties['__requestBody__'] = JsonSchemaObject.model_validate(callback_request_body_params)
+        
+        # Extract callback output schema
+        callback_responses = callback_operation.get('responses', {})
+        callback_response = callback_responses.get(str(http_success_response_code), {})
+        callback_response_description = callback_response.get('description')
+        callback_response_schema = callback_response.get('content', {}).get(http_response_content_type, {}).get('schema', {})
+        
+        callback_response_schema['required'] = []
+        callback_output_schema = ToolResponseBody.model_validate(callback_response_schema)
+        callback_output_schema.description = callback_response_description
+
+        # Remove callbackUrl parameter from main tool input schema
+        original_input_schema = ToolRequestBody(
             type='object',
             properties={k: v for k, v in spec.input_schema.properties.items() if not k.endswith('_callbackUrl')},
             required=[r for r in spec.input_schema.required if not r.endswith('_callbackUrl')]
         )
+        spec.input_schema = original_input_schema
 
-        if callback_input_schema:
-            spec.input_schema = callback_input_schema
-
+        original_response_schema = spec.output_schema
+        
         callback_binding = CallbackBinding(
             callback_url=callback_path,
             method=callback_method.upper(),
-            input_schema=callback_input_schema,
-            output_schema=spec.output_schema
+            output_schema=callback_output_schema
         )
 
+        # Create acknowledgement binding with the original response schema
+        acknowledgement_binding = AcknowledgementBinding(
+            output_schema=original_response_schema
+        )
+        
+        # For async tools, set the main tool's output_schema to the callback's input_schema
+        spec.output_schema = callback_input_schema
+
     else:
         callback_binding = None
+        acknowledgement_binding = None
 
     openapi_binding = OpenApiToolBinding(
         http_path=http_path,
@@ -247,6 +295,9 @@ def create_openapi_json_tool(
     if callback_binding is not None:
         openapi_binding.callback = callback_binding
 
+    if acknowledgement_binding is not None:
+        openapi_binding.acknowledgement = acknowledgement_binding
+
     spec.binding = ToolBinding(openapi=openapi_binding)
 
     return OpenAPITool(spec=spec)
@@ -260,23 +311,23 @@ async def _get_openapi_spec_from_uri(openapi_uri: str) -> Dict[str, Any]:
             elif openapi_uri.endswith('.yaml') or openapi_uri.endswith('.yml'):
                 openapi_contents = yaml_safe_load(fp)
             else:
-                raise ValueError(
+                raise BadRequest(
                     f"Unexpected file extension for file {openapi_uri}, expected one of [.json, .yaml, .yml]")
     elif openapi_uri.endswith('.json'):
         async with httpx.AsyncClient() as client:
             r = await client.get(openapi_uri)
             if r.status_code != 200:
-                raise ValueError(f"Failed to fetch an openapi spec from {openapi_uri}, status code: {r.status_code}")
+                raise BadRequest(f"Failed to fetch an openapi spec from {openapi_uri}, status code: {r.status_code}")
             openapi_contents = r.json()
     elif openapi_uri.endswith('.yaml'):
         async with httpx.AsyncClient() as client:
             r = await client.get(openapi_uri)
             if r.status_code != 200:
-                raise ValueError(f"Failed to fetch an openapi spec from {openapi_uri}, status code: {r.status_code}")
+                raise BadRequest(f"Failed to fetch an openapi spec from {openapi_uri}, status code: {r.status_code}")
             openapi_contents = yaml_safe_load(r.text)
 
     if openapi_contents is None:
-        raise ValueError(f"Unrecognized path or uri {openapi_uri}")
+        raise BadRequest(f"Unrecognized path or uri {openapi_uri}")
 
     return openapi_contents