ibm-watsonx-orchestrate 1.8.0b0__py3-none-any.whl → 1.9.0b0__py3-none-any.whl

ibm_watsonx_orchestrate/__init__.py

@@ -5,7 +5,7 @@
 
 pkg_name = "ibm-watsonx-orchestrate"
 
-__version__ = "1.8.0b0"
+__version__ = "1.9.0b0"
 
 
 

ibm_watsonx_orchestrate/agent_builder/agents/types.py

@@ -29,6 +29,12 @@ yaml.representer.SafeRepresenter.add_representer(str, str_presenter) # to use wi
 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"
@@ -104,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)
 

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/tools/openapi_tool.py

@@ -14,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
@@ -207,35 +207,82 @@ def create_openapi_json_tool(
 
     # 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,
@@ -248,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)

ibm_watsonx_orchestrate/agent_builder/tools/types.py

@@ -97,9 +97,13 @@ HTTP_METHOD = Literal['GET', 'POST', 'PUT', 'PATCH', 'DELETE']
 class CallbackBinding(BaseModel):
     callback_url: str
     method: HTTP_METHOD
-    input_schema: ToolRequestBody
+    input_schema: Optional[ToolRequestBody] = None
     output_schema: ToolResponseBody
 
+class AcknowledgementBinding(BaseModel):
+    output_schema: ToolResponseBody
+
+
 class OpenApiToolBinding(BaseModel):
     http_method: HTTP_METHOD
     http_path: str
@@ -107,7 +111,8 @@ class OpenApiToolBinding(BaseModel):
     security: Optional[List[OpenApiSecurityScheme]] = None
     servers: Optional[List[str]] = None
     connection_id: str | None = None
-    callback: CallbackBinding = None
+    callback: Optional[CallbackBinding] = None
+    acknowledgement: Optional[AcknowledgementBinding] = None
 
     @model_validator(mode='after')
     def validate_openapi_tool_binding(self):

ibm_watsonx_orchestrate/cli/commands/agents/agents_controller.py

@@ -769,7 +769,7 @@ class AgentsController:
                 for agent in native_agents:
                     agents_list.append(json.loads(agent.dumps_spec()))
 
-                rich.print(rich.json.JSON(json.dumps(agents_list, indent=4)))
+                rich.print_json(json.dumps(agents_list, indent=4))
             else:
                 native_table = rich.table.Table(
                     show_header=True, 
@@ -832,7 +832,7 @@ class AgentsController:
             if verbose:
                 for agent in external_agents:
                     external_agents_list.append(json.loads(agent.dumps_spec()))
-                rich.print(rich.json.JSON(json.dumps(external_agents_list, indent=4)))
+                rich.print_json(json.dumps(external_agents_list, indent=4))
             else:
                 external_table = rich.table.Table(
                     show_header=True, 
@@ -900,7 +900,7 @@ class AgentsController:
 
             if verbose:
                 for agent in assistant_agents:
-                    rich.print(agent.dumps_spec())
+                    rich.print_json(agent.dumps_spec())
             else:
                 assistants_table = rich.table.Table(
                     show_header=True, 

ibm_watsonx_orchestrate/cli/commands/channels/types.py

@@ -1,6 +1,6 @@
 from enum import Enum
 
-class  EnvironmentType(str, Enum):
+class EnvironmentType(str, Enum):
     DRAFT ='draft'
     LIVE = 'live'
 
@@ -8,8 +8,21 @@ class  EnvironmentType(str, Enum):
         return self.value
     
 
-class  ChannelType(str, Enum):
+class ChannelType(str, Enum):
     WEBCHAT ='webchat'
 
     def __str__(self):
+        return self.value
+
+
+class RuntimeEnvironmentType(str, Enum):
+    LOCAL = 'local'
+    CPD = 'cpd'
+    IBM_CLOUD = 'ibmcloud'
+    AWS = 'aws'
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
         return self.value

ibm_watsonx_orchestrate/cli/commands/channels/webchat/channels_webchat_controller.py

@@ -4,12 +4,14 @@ import jwt
 import sys
 
 from ibm_watsonx_orchestrate.cli.config import Config, ENV_WXO_URL_OPT, ENVIRONMENTS_SECTION_HEADER, CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT, CHAT_UI_PORT
+from ibm_watsonx_orchestrate.cli.commands.channels.types import RuntimeEnvironmentType
 from ibm_watsonx_orchestrate.client.utils import is_local_dev, is_ibm_cloud_platform, get_environment, get_cpd_instance_id_from_url, is_saas_env, AUTH_CONFIG_FILE_FOLDER, AUTH_SECTION_HEADER, AUTH_MCSP_TOKEN_OPT, AUTH_CONFIG_FILE
 
 from ibm_watsonx_orchestrate.client.agents.agent_client import AgentClient
 
 from ibm_watsonx_orchestrate.client.utils import instantiate_client
 
+
 logger = logging.getLogger(__name__)
 
 class ChannelsWebchatController:
@@ -95,8 +97,6 @@ class ChannelsWebchatController:
         if target_env == 'draft' and is_saas == True:
             logger.error(f'For SAAS, please ensure this agent exists in a Live Environment')
             exit(1)
-             
-
 
         return filtered_environments[0].get("id")
 
@@ -158,13 +158,13 @@ class ChannelsWebchatController:
         environment = get_environment()
 
         match (environment):
-            case "local":
+            case RuntimeEnvironmentType.LOCAL:
                 tenant_id = self.get_tenant_id_local()
 
-            case "cpd":
+            case RuntimeEnvironmentType.CPD:
                 tenant_id = get_cpd_instance_id_from_url()
 
-            case "ibmcloud":
+            case RuntimeEnvironmentType.IBM_CLOUD:
                 crn = input("Please enter your CRN which can be retrieved from the IBM Cloud UI: ")
                 if crn == "":
                     logger.error("You must enter your CRN for IBM Cloud instances")
@@ -175,13 +175,13 @@ class ChannelsWebchatController:
                     sys.exit(1)
                 tenant_id = self.extract_tenant_id_from_crn(crn)
 
-            case "ga":
+            case RuntimeEnvironmentType.AWS:
                 tenant_id = self.get_tenant_id()
 
             case _:
                 logger.error("Environment not recognized")
                 sys.exit(1)
-            
+
         host_url = self.get_host_url()
         agent_id = self.get_agent_id(self.agent_name)
         agent_env_id = self.get_environment_id(self.agent_name, self.env)

ibm_watsonx_orchestrate/cli/commands/connections/connections_command.py

@@ -201,6 +201,13 @@ def set_credentials_connection_command(
             help='For oauth_auth_client_credentials_flow, the client_secret to authenticate with'
         )
     ] = None,
+    send_via: Annotated[
+        str,
+        typer.Option(
+            '--send-via',
+            help='For oauth_auth_client_credentials_flow, how the token will be sent to the server. Defaults to using `header`'
+        )
+    ] = None,
     token_url: Annotated[
         str,
         typer.Option(
@@ -220,14 +227,14 @@ def set_credentials_connection_command(
         str,
         typer.Option(
             '--grant-type',
-            help='For oauth_auth_on_behalf_of_flow, the grant type used by the application token server'
+            help='For oauth_auth_on_behalf_of_flow and oauth_auth_client_credentials_flow, the grant type used by the application token server'
         )
     ] = None,
-    scopes: Annotated[
-        List[str],
+    scope: Annotated[
+        str,
         typer.Option(
-            '--scopes',
-            help='For oauth_auth_code_flow and oauth_auth_client_credentials_flow, the optional scopes used by the application token server'
+            '--scope',
+            help='For oauth_auth_code_flow and oauth_auth_client_credentials_flow, the optional scopes used by the application token server. Should be in the form of a space seperated string.'
         )
     ] = None,
     entries: Annotated[
@@ -247,10 +254,11 @@ def set_credentials_connection_command(
         api_key=api_key,
         client_id=client_id,
         client_secret=client_secret,
+        send_via=send_via,
         token_url=token_url,
         auth_url=auth_url,
         grant_type=grant_type,
-        scopes=scopes,
+        scope=scope,
         entries=entries
     )
 

ibm_watsonx_orchestrate/cli/commands/connections/connections_controller.py

@@ -160,13 +160,13 @@ def _validate_connection_params(type: ConnectionType, **args) -> None:
             f"Missing flags --token-url is required for type {type}"
         )
 
-
     if type == ConnectionType.OAUTH_ON_BEHALF_OF_FLOW and (
             args.get('grant_type') is None
     ):
         raise typer.BadParameter(
             f"Missing flags --grant-type is required for type {type}"
         )
+    
 
 def _parse_entry(entry: str) -> dict[str,str]:
     split_entry = entry.split('=')
@@ -197,15 +197,13 @@ def _get_credentials(type: ConnectionType, **kwargs):
                 client_id=kwargs.get("client_id"),
                 client_secret=kwargs.get("client_secret"),
                 token_url=kwargs.get("token_url"),
-                scopes=kwargs.get("scopes")
+                scope=kwargs.get("scope")
             )
         case ConnectionType.OAUTH2_CLIENT_CREDS:
-            return OAuth2ClientCredentials(
-                client_id=kwargs.get("client_id"),
-                client_secret=kwargs.get("client_secret"),
-                token_url=kwargs.get("token_url"),
-                scopes=kwargs.get("scopes")
-            )
+            # using filtered args as default values will not be set if 'None' is passed, causing validation errors
+            keys = ["client_id","client_secret","token_url","grant_type","send_via", "scope"]
+            filtered_args = { key_name: kwargs[key_name] for key_name in keys if kwargs.get(key_name) }
+            return OAuth2ClientCredentials(**filtered_args)
         # case ConnectionType.OAUTH2_IMPLICIT:
         #     return OAuth2ImplicitCredentials(
         #         authorization_url=kwargs.get("auth_url"),