ibm-watsonx-orchestrate 1.5.1__py3-none-any.whl → 1.6.0__py3-none-any.whl

ibm_watsonx_orchestrate/__init__.py

@@ -5,7 +5,7 @@
 
 pkg_name = "ibm-watsonx-orchestrate"
 
-__version__ = "1.5.1"
+__version__ = "1.6.0"
 
 
 

ibm_watsonx_orchestrate/agent_builder/agents/__init__.py

@@ -2,4 +2,4 @@ from .agent import Agent, AgentSpec
 from .external_agent import ExternalAgent, ExternalAgentSpec
 from .assistant_agent import AssistantAgent, AssistantAgentSpec
 # from .types import AgentKind, AgentStyle, ExternalAgentConfig, AssistantAgentConfig, SpecVersion
-from .types import AgentKind, AgentStyle, SpecVersion, ExternalAgentAuthScheme, AgentProvider, AssistantAgentConfig
+from .types import AgentKind, AgentStyle, SpecVersion, ExternalAgentAuthScheme, AgentProvider, AssistantAgentConfig, AgentGuideline

ibm_watsonx_orchestrate/agent_builder/agents/agent.py

@@ -14,6 +14,7 @@ class Agent(AgentSpec):
                 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")
             agent = Agent.model_validate(content)

ibm_watsonx_orchestrate/agent_builder/agents/types.py

@@ -4,8 +4,9 @@ from enum import Enum
 from typing import List, Optional, Dict
 from pydantic import BaseModel, model_validator, ConfigDict
 from ibm_watsonx_orchestrate.agent_builder.tools import BaseTool, PythonTool
-from ibm_watsonx_orchestrate.agent_builder.knowledge_bases.types import KnowledgeBaseSpec
+from ibm_watsonx_orchestrate.agent_builder.knowledge_bases.types import KnowledgeBaseSpec, KnowledgeBaseBuiltInVectorIndexConfig, HAPFiltering, HAPFilteringConfig, CitationsConfig, ConfidenceThresholds, QueryRewriteConfig, GenerationConfiguration
 from ibm_watsonx_orchestrate.agent_builder.knowledge_bases.knowledge_base import KnowledgeBase
+from ibm_watsonx_orchestrate.agent_builder.agents.webchat_customizations import StarterPrompts, WelcomeContent
 from pydantic import Field, AliasChoices
 from typing import Annotated
 
@@ -32,7 +33,8 @@ class AgentProvider(str, Enum):
     WXAI = "wx.ai"
     EXT_CHAT = "external_chat"
     SALESFORCE = "salesforce"
-    WATSONX = "watsonx" #provider type returned from an assistant agent
+    WATSONX = "watsonx"
+    A2A = 'external_chat/A2A/0.2.1' #provider type returned from an assistant agent
 
 
 class AssistantAgentAuthType(str, Enum):
@@ -50,6 +52,8 @@ class BaseAgentSpec(BaseModel):
     name: Annotated[str, Field(json_schema_extra={"min_length_str":1})]
     display_name: Annotated[Optional[str], Field(json_schema_extra={"min_length_str":1})] = None
     description: Annotated[str, Field(json_schema_extra={"min_length_str":1})]
+    context_access_enabled: bool = True
+    context_variables: Optional[List[str]] = []
 
     def dump_spec(self, file: str) -> None:
         dumped = self.model_dump(mode='json', exclude_unset=True, exclude_none=True)
@@ -69,11 +73,34 @@ class BaseAgentSpec(BaseModel):
 #      NATIVE AGENT TYPES
 # ===============================
 
+class ChatWithDocsConfig(BaseModel):
+    enabled: Optional[bool] = None
+    vector_index: Optional[KnowledgeBaseBuiltInVectorIndexConfig] = None
+    generation:  Optional[GenerationConfiguration] = None
+    query_rewrite:  Optional[QueryRewriteConfig] = None
+    confidence_thresholds: Optional[ConfidenceThresholds] =None
+    citations:  Optional[CitationsConfig] = None
+    hap_filtering: Optional[HAPFiltering] = None
+    
 class AgentStyle(str, Enum):
     DEFAULT = "default"
     REACT = "react"
     PLANNER = "planner"
 
+class AgentGuideline(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    display_name: Optional[str] = None
+    condition: str
+    action: str
+    tool: Optional[BaseTool] | Optional[str] = None
+
+    def __init__(self, *args, **kwargs):
+        if "tool" in kwargs and kwargs["tool"]:
+            kwargs["tool"] = kwargs['tool'].__tool_spec__.name if isinstance(kwargs['tool'], BaseTool) else kwargs["tool"]
+
+        super().__init__(*args, **kwargs)
+
 class AgentSpec(BaseAgentSpec):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -83,10 +110,14 @@ class AgentSpec(BaseAgentSpec):
     custom_join_tool: str | PythonTool | None = None
     structured_output: Optional[JsonSchemaObject] = None
     instructions: Annotated[Optional[str], Field(json_schema_extra={"min_length_str":1})] = None
+    guidelines: Optional[List[AgentGuideline]] = None
     collaborators: Optional[List[str]] | Optional[List['BaseAgentSpec']] = []
     tools: Optional[List[str]] | Optional[List['BaseTool']] = []
     hidden: bool = False
     knowledge_base: Optional[List[str]] | Optional[List['KnowledgeBaseSpec']] = []
+    chat_with_docs: Optional[ChatWithDocsConfig] = None
+    starter_prompts: Optional[StarterPrompts] = None
+    welcome_content: Optional[WelcomeContent] = None
 
 
     def __init__(self, *args, **kwargs):
@@ -122,11 +153,17 @@ def validate_agent_fields(values: dict) -> dict:
             raise ValueError(f"Circular reference detected. The agent '{name}' cannot contain itself as a collaborator")
 
     if values.get("style") == AgentStyle.PLANNER:
-        if not values.get("custom_join_tool") and not values.get("structured_output"):
-            raise ValueError("Either 'custom_join_tool' or 'structured_output' must be provided for planner style agents.")
         if values.get("custom_join_tool") and values.get("structured_output"):
             raise ValueError("Only one of 'custom_join_tool' or 'structured_output' can be provided for planner style agents.")
 
+    context_variables = values.get("context_variables")
+    if context_variables is not None:
+        if not isinstance(context_variables, list):
+            raise ValueError("context_variables must be a list")
+        for var in context_variables:
+            if not isinstance(var, str) or not var.strip():
+                raise ValueError("All context_variables must be non-empty strings")
+
     return values
 
 # ===============================
@@ -170,6 +207,14 @@ def validate_external_agent_fields(values: dict) -> dict:
         if value and not str(value).strip():
             raise ValueError(f"{field} cannot be empty or just whitespace")
 
+    context_variables = values.get("context_variables")
+    if context_variables is not None:
+        if not isinstance(context_variables, list):
+            raise ValueError("context_variables must be a list")
+        for var in context_variables:
+            if not isinstance(var, str) or not var.strip():
+                raise ValueError("All context_variables must be non-empty strings")
+
     return values
 
 # # ===============================
@@ -215,4 +260,13 @@ def validate_assistant_agent_fields(values: dict) -> dict:
         if value and not str(value).strip():
             raise ValueError(f"{field} cannot be empty or just whitespace")
 
+    # Validate context_variables if provided
+    context_variables = values.get("context_variables")
+    if context_variables is not None:
+        if not isinstance(context_variables, list):
+            raise ValueError("context_variables must be a list")
+        for var in context_variables:
+            if not isinstance(var, str) or not var.strip():
+                raise ValueError("All context_variables must be non-empty strings")
+
     return values

ibm_watsonx_orchestrate/agent_builder/agents/webchat_customizations/__init__.py

@@ -0,0 +1,2 @@
+from .prompts import AgentPrompt, StarterPrompts
+from .welcome_content import WelcomeContent

ibm_watsonx_orchestrate/agent_builder/agents/webchat_customizations/prompts.py

@@ -0,0 +1,34 @@
+from enum import Enum
+from typing import Optional, Dict, List, Annotated
+from annotated_types import Len
+from pydantic import BaseModel, model_validator
+
+
+class PromptState(str,Enum):
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+    MISSING = ""
+
+
+class AgentPrompt(BaseModel):
+    id: str
+    title: str
+    subtitle: Optional[str] = None
+    prompt: str
+    state: PromptState = PromptState.ACTIVE
+        
+    @model_validator(mode='before')
+    def validate_fields(cls,values):
+        return validate_agent_prompt_fields(values)
+
+
+def validate_agent_prompt_fields(values: Dict):
+    for field in ['id','title','prompt','state']:
+        value = values.get(field)
+        if value and not str(value).strip():
+            raise ValueError(f"{field} cannot be empty or just whitespace")
+    return values
+
+class StarterPrompts(BaseModel):
+    is_default_prompts: bool = False
+    prompts: Annotated[List[AgentPrompt], Len(min_length=1)]

ibm_watsonx_orchestrate/agent_builder/agents/webchat_customizations/welcome_content.py

@@ -0,0 +1,20 @@
+
+from typing import Optional,Dict
+from pydantic import BaseModel, model_validator
+
+class WelcomeContent(BaseModel):
+    welcome_message: str
+    description: Optional[str] = None
+    is_default_message: bool = False
+
+    @model_validator(mode='before')
+    def validate_fields(cls,values):
+        return validate_welcome_content_fields(values)
+
+
+def validate_welcome_content_fields(values: Dict):
+    for field in ['welcome_message']:
+        value = values.get(field)
+        if value and not str(value).strip():
+            raise ValueError(f"{field} cannot be empty or just whitespace")
+    return values

ibm_watsonx_orchestrate/agent_builder/connections/__init__.py

@@ -15,8 +15,8 @@ from .types import (
     BearerTokenAuthCredentials,
     APIKeyAuthCredentials,
     OAuth2TokenCredentials,
-    # OAuth2AuthCodeCredentials,
-    # OAuth2ClientCredentials,
+    OAuth2AuthCodeCredentials,
+    OAuth2ClientCredentials,
     # OAuth2ImplicitCredentials,
     # OAuth2PasswordCredentials,
     OAuthOnBehalfOfCredentials,

ibm_watsonx_orchestrate/agent_builder/connections/types.py

@@ -6,10 +6,10 @@ class ConnectionKind(str, Enum):
     basic = 'basic'
     bearer = 'bearer'
     api_key = 'api_key'
-    # oauth_auth_code_flow = 'oauth_auth_code_flow'
+    oauth_auth_code_flow = 'oauth_auth_code_flow'
     # oauth_auth_implicit_flow = 'oauth_auth_implicit_flow'
     # oauth_auth_password_flow = 'oauth_auth_password_flow'
-    # oauth_auth_client_credentials_flow = 'oauth_auth_client_credentials_flow'
+    oauth_auth_client_credentials_flow = 'oauth_auth_client_credentials_flow'
     oauth_auth_on_behalf_of_flow = 'oauth_auth_on_behalf_of_flow'
     key_value = 'key_value'
     kv = 'kv'
@@ -32,10 +32,10 @@ class ConnectionPreference(str, Enum):
         return self.value
 
 class ConnectionAuthType(str, Enum):
-    # OAUTH2_AUTH_CODE = 'oauth2_auth_code'
+    OAUTH2_AUTH_CODE = 'oauth2_auth_code'
     # OAUTH2_IMPLICIT = 'oauth2_implicit'
     # OAUTH2_PASSWORD = 'oauth2_password'
-    # OAUTH2_CLIENT_CREDS = 'oauth2_client_creds'
+    OAUTH2_CLIENT_CREDS = 'oauth2_client_creds'
     OAUTH_ON_BEHALF_OF_FLOW = 'oauth_on_behalf_of_flow'
 
     def __str__(self):
@@ -63,10 +63,10 @@ class ConnectionType(str, Enum):
     BASIC_AUTH = ConnectionSecurityScheme.BASIC_AUTH.value
     BEARER_TOKEN = ConnectionSecurityScheme.BEARER_TOKEN.value
     API_KEY_AUTH = ConnectionSecurityScheme.API_KEY_AUTH.value
-    # OAUTH2_AUTH_CODE = ConnectionAuthType.OAUTH2_AUTH_CODE.value
+    OAUTH2_AUTH_CODE = ConnectionAuthType.OAUTH2_AUTH_CODE.value
     # OAUTH2_IMPLICIT = ConnectionAuthType.OAUTH2_IMPLICIT.value
     # OAUTH2_PASSWORD = ConnectionAuthType.OAUTH2_PASSWORD.value
-    # OAUTH2_CLIENT_CREDS = ConnectionAuthType.OAUTH2_CLIENT_CREDS.value
+    OAUTH2_CLIENT_CREDS = ConnectionAuthType.OAUTH2_CLIENT_CREDS.value
     OAUTH_ON_BEHALF_OF_FLOW = ConnectionAuthType.OAUTH_ON_BEHALF_OF_FLOW.value
     KEY_VALUE = ConnectionSecurityScheme.KEY_VALUE.value
 
@@ -77,8 +77,8 @@ class ConnectionType(str, Enum):
         return repr(self.value)
 
 OAUTH_CONNECTION_TYPES = {
-    # ConnectionType.OAUTH2_AUTH_CODE,
-    # ConnectionType.OAUTH2_CLIENT_CREDS,
+    ConnectionType.OAUTH2_AUTH_CODE,
+    ConnectionType.OAUTH2_CLIENT_CREDS,
     # ConnectionType.OAUTH2_IMPLICIT,
     # ConnectionType.OAUTH2_PASSWORD,
     ConnectionType.OAUTH_ON_BEHALF_OF_FLOW,
@@ -137,10 +137,15 @@ class ConnectionConfiguration(BaseModel):
 
     @model_validator(mode="after")
     def validate_config(self):
-        if self.sso and self.security_scheme != ConnectionSecurityScheme.OAUTH2:
-            raise ValueError(f"SSO not supported for auth scheme '{self.security_scheme}'. SSO can only be used with OAuth auth types")
-        if not self.sso and self.security_scheme == ConnectionSecurityScheme.OAUTH2:
-            raise ValueError(f"SSO required for OAuth auth schemes. Please enable SSO.")
+        conn_type = None
+        if self.security_scheme == ConnectionSecurityScheme.OAUTH2:
+            conn_type = self.auth_type
+        else:
+            conn_type = self.security_scheme
+        if self.sso and conn_type != ConnectionAuthType.OAUTH_ON_BEHALF_OF_FLOW:
+            raise ValueError(f"SSO not supported for auth scheme '{conn_type}'. SSO can only be used with OAuth auth types")
+        if not self.sso and conn_type == ConnectionAuthType.OAUTH_ON_BEHALF_OF_FLOW:
+            raise ValueError(f"SSO required for '{conn_type}'. Please enable SSO.")
         if self.sso:
             if not self.idp_config_data:
                 raise ValueError("For SSO auth 'idp_config_data' is a required field")
@@ -167,11 +172,12 @@ class OAuth2TokenCredentials(BaseModel):
     access_token: str
     url: Optional[str] = None
 
-# class OAuth2AuthCodeCredentials(BaseModel):
-#     client_id: str
-#     client_secret: str
-#     token_url: str
-#     authorization_url: str
+class OAuth2AuthCodeCredentials(BaseModel):
+    client_id: str
+    client_secret: str
+    token_url: str
+    authorization_url: str
+    scopes : Optional[List[str]] = None
 
 # class OAuth2ImplicitCredentials(BaseModel):
 #     client_id: str
@@ -183,10 +189,11 @@ class OAuth2TokenCredentials(BaseModel):
 #     token_url: str
 #     authorization_url: str
 
-# class OAuth2ClientCredentials(BaseModel):
-#     client_id: str
-#     client_secret: str
-#     token_url: str
+class OAuth2ClientCredentials(BaseModel):
+    client_id: str
+    client_secret: str
+    token_url: str
+    scopes : Optional[List[str]] = None
 
 class OAuthOnBehalfOfCredentials(BaseModel):
     client_id: str
@@ -205,10 +212,10 @@ CREDENTIALS_SET = Union[
     BasicAuthCredentials,
     BearerTokenAuthCredentials,
     APIKeyAuthCredentials,
-    # OAuth2AuthCodeCredentials,
+    OAuth2AuthCodeCredentials,
     # OAuth2ImplicitCredentials,
     # OAuth2PasswordCredentials,
-    # OAuth2ClientCredentials,
+    OAuth2ClientCredentials,
     OAuthOnBehalfOfCredentials,
     KeyValueConnectionCredentials
 ]
@@ -219,20 +226,20 @@ CONNECTION_KIND_SCHEME_MAPPING = {
     ConnectionKind.basic: ConnectionSecurityScheme.BASIC_AUTH,
     ConnectionKind.bearer: ConnectionSecurityScheme.BEARER_TOKEN,
     ConnectionKind.api_key: ConnectionSecurityScheme.API_KEY_AUTH,
-    # ConnectionKind.oauth_auth_code_flow: ConnectionSecurityScheme.OAUTH2,
+    ConnectionKind.oauth_auth_code_flow: ConnectionSecurityScheme.OAUTH2,
     # ConnectionKind.oauth_auth_implicit_flow: ConnectionSecurityScheme.OAUTH2,
     # ConnectionKind.oauth_auth_password_flow: ConnectionSecurityScheme.OAUTH2,
-    # ConnectionKind.oauth_auth_client_credentials_flow: ConnectionSecurityScheme.OAUTH2,
+    ConnectionKind.oauth_auth_client_credentials_flow: ConnectionSecurityScheme.OAUTH2,
     ConnectionKind.oauth_auth_on_behalf_of_flow: ConnectionSecurityScheme.OAUTH2,
     ConnectionKind.key_value: ConnectionSecurityScheme.KEY_VALUE,
     ConnectionKind.kv: ConnectionSecurityScheme.KEY_VALUE,
 }
 
 CONNECTION_KIND_OAUTH_TYPE_MAPPING = {
-    # ConnectionKind.oauth_auth_code_flow: ConnectionAuthType.OAUTH2_AUTH_CODE,
+    ConnectionKind.oauth_auth_code_flow: ConnectionAuthType.OAUTH2_AUTH_CODE,
     # ConnectionKind.oauth_auth_implicit_flow: ConnectionAuthType.OAUTH2_IMPLICIT,
     # ConnectionKind.oauth_auth_password_flow: ConnectionAuthType.OAUTH2_PASSWORD,
-    # ConnectionKind.oauth_auth_client_credentials_flow: ConnectionAuthType.OAUTH2_CLIENT_CREDS,
+    ConnectionKind.oauth_auth_client_credentials_flow: ConnectionAuthType.OAUTH2_CLIENT_CREDS,
     ConnectionKind.oauth_auth_on_behalf_of_flow: ConnectionAuthType.OAUTH_ON_BEHALF_OF_FLOW,
 }
 
@@ -240,10 +247,10 @@ CONNECTION_TYPE_CREDENTIAL_MAPPING = {
     ConnectionType.BASIC_AUTH: BasicAuthCredentials,
     ConnectionType.BEARER_TOKEN: BearerTokenAuthCredentials,
     ConnectionType.API_KEY_AUTH: APIKeyAuthCredentials,
-    # ConnectionType.OAUTH2_AUTH_CODE: BearerTokenAuthCredentials,
-    # ConnectionType.OAUTH2_IMPLICIT: BearerTokenAuthCredentials,
-    # ConnectionType.OAUTH2_PASSWORD: BearerTokenAuthCredentials,
-    # ConnectionType.OAUTH2_CLIENT_CREDS: BearerTokenAuthCredentials,
+    ConnectionType.OAUTH2_AUTH_CODE: OAuth2TokenCredentials,
+    # ConnectionType.OAUTH2_IMPLICIT: OAuth2TokenCredentials,
+    # ConnectionType.OAUTH2_PASSWORD: OAuth2TokenCredentials,
+    ConnectionType.OAUTH2_CLIENT_CREDS: OAuth2TokenCredentials,
     ConnectionType.OAUTH_ON_BEHALF_OF_FLOW: OAuth2TokenCredentials,
     ConnectionType.KEY_VALUE: KeyValueConnectionCredentials,
 }

ibm_watsonx_orchestrate/agent_builder/model_policies/types.py

@@ -17,7 +17,7 @@ class ModelPolicyRetry(BaseModel):
     on_status_codes: List[int] = None
 
 class ModelPolicyTarget(BaseModel):
-    weight: float = None
+    weight: float | None = None
     model_name: str = None
 
 class ModelPolicyInner(BaseModel):

ibm_watsonx_orchestrate/agent_builder/models/types.py

@@ -146,7 +146,6 @@ class ProviderConfig(BaseModel):
 
     # Azure Inference
     azure_deployment_name: Optional[str] = Field(None, alias="azureDeploymentName")
-    azure_api_version: Optional[str] = Field(None, alias="azureApiVersion")
     azure_extra_params: Optional[str] = Field(None, alias="azureExtraParams")
     azure_foundry_url: Optional[str] = Field(None, alias="azureFoundryUrl")
 

ibm_watsonx_orchestrate/agent_builder/tools/flow_tool.py

@@ -0,0 +1,83 @@
+
+import json
+import logging
+
+from ibm_watsonx_orchestrate.utils.utils import yaml_safe_load
+from .types import FlowToolBinding, ToolBinding, ToolSpec
+from .base_tool import BaseTool
+from .types import ToolPermission
+
+import json
+
+logger = logging.getLogger(__name__)
+
+
+class FlowTool(BaseTool):
+    def __init__(self, spec: ToolSpec):
+        BaseTool.__init__(self, spec=spec)
+
+    async def __call__(self, **kwargs):
+        raise RuntimeError('Flow Tools are only available when deployed onto watson orchestrate or the watson '
+                           'orchestrate-light runtime')
+
+    @staticmethod
+    def from_spec(file: str) -> 'FlowTool':
+        with open(file, 'r') as f:
+            if file.endswith('.yaml') or file.endswith('.yml'):
+                spec = ToolSpec.model_validate(yaml_safe_load(f))
+            elif file.endswith('.json'):
+                spec = ToolSpec.model_validate(json.load(f))
+            else:
+                raise ValueError('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')
+
+        return FlowTool(spec=spec)
+
+    def __repr__(self):
+        return f"FlowTool(model={self.__tool_spec__.binding.flow.model}, name='{self.__tool_spec__.name}', description='{self.__tool_spec__.description}')"
+
+    def __str__(self):
+        return self.__repr__()
+
+    @property
+    def __doc__(self):
+        return self.__tool_spec__.description
+
+
+def create_flow_json_tool(
+        flow_model: dict,
+        name: str = None,
+        description: str = None,
+        permission: ToolPermission = None,
+        ) -> FlowTool:
+    """
+    Creates a flow tool from a Flow JSON model
+
+    Here we create the basic tool spec.  The remaining properties of the tool spec
+    are set by the server when the tool is registered.  The server will publish the model to the
+    flow engine and generate the rest of the tool spec based on it's openAPI specification.
+    """
+
+    spec_name = name
+    spec_permission = permission
+    if spec_name is None:
+        raise ValueError(
+            f"No name provided for tool.")
+
+    spec_description = description
+    if spec_description is None:
+        raise ValueError(
+            f"No description provided for tool.")
+
+    spec = ToolSpec(
+        name=spec_name,
+        description=spec_description,
+        permission=spec_permission
+    )
+
+    spec.binding = ToolBinding(flow=FlowToolBinding(flow_id=name, model=flow_model))
+
+    return FlowTool(spec=spec)
+

ibm_watsonx_orchestrate/agent_builder/tools/openapi_tool.py

@@ -14,7 +14,7 @@ from .types import ToolSpec
 from .base_tool import BaseTool
 from .types import HTTP_METHOD, ToolPermission, ToolRequestBody, ToolResponseBody, \
     OpenApiToolBinding, \
-    JsonSchemaObject, ToolBinding, OpenApiSecurityScheme
+    JsonSchemaObject, ToolBinding, OpenApiSecurityScheme, CallbackBinding
 
 import json
 
@@ -134,6 +134,7 @@ def create_openapi_json_tool(
         description=spec_description,
         permission=spec_permission
     )
+    spec.is_async = 'callbacks' in route_spec
 
     spec.input_schema = input_schema or ToolRequestBody(
         type='object',
@@ -203,13 +204,50 @@ def create_openapi_json_tool(
 
         security.append(security_schemes_map[name])
 
-    spec.binding = ToolBinding(openapi=OpenApiToolBinding(
+    # 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()))
+        
+        # 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
+        callback_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')]
+        )
+
+        if callback_input_schema:
+            spec.input_schema = callback_input_schema
+
+        callback_binding = CallbackBinding(
+            callback_url=callback_path,
+            method=callback_method.upper(),
+            input_schema=callback_input_schema,
+            output_schema=spec.output_schema
+        )
+
+    else:
+        callback_binding = None
+
+    openapi_binding = OpenApiToolBinding(
         http_path=http_path,
         http_method=http_method,
         security=security,
         servers=servers,
         connection_id=connection_id
-    ))
+    )
+    
+    if callback_binding is not None:
+        openapi_binding.callback = callback_binding
+
+    spec.binding = ToolBinding(openapi=openapi_binding)
 
     return OpenAPITool(spec=spec)
 

ibm_watsonx_orchestrate/agent_builder/tools/python_tool.py

@@ -95,7 +95,8 @@ def _fix_optional(schema):
 def _validate_input_schema(input_schema: ToolRequestBody) -> None:
     props = input_schema.properties
     for prop in props:
-        if not props.get(prop).type:
+        property_schema = props.get(prop)
+        if not (property_schema.type or property_schema.anyOf):
             logger.warning(f"Missing type hint for tool property '{prop}' defaulting to 'str'. To remove this warning add a type hint to the property in the tools signature. See Python docs for guidance: https://docs.python.org/3/library/typing.html")
 
 def _validate_join_tool_func(fn: Callable, sig: inspect.Signature | None = None, name: str | None = None) -> None:

ibm_watsonx_orchestrate/agent_builder/tools/types.py

@@ -93,6 +93,11 @@ class OpenApiSecurityScheme(BaseModel):
 
 HTTP_METHOD = Literal['GET', 'POST', 'PUT', 'PATCH', 'DELETE']
 
+class CallbackBinding(BaseModel):
+    callback_url: str
+    method: HTTP_METHOD
+    input_schema: ToolRequestBody
+    output_schema: ToolResponseBody
 
 class OpenApiToolBinding(BaseModel):
     http_method: HTTP_METHOD
@@ -101,6 +106,7 @@ class OpenApiToolBinding(BaseModel):
     security: Optional[List[OpenApiSecurityScheme]] = None
     servers: Optional[List[str]] = None
     connection_id: str | None = None
+    callback: CallbackBinding = None
 
     @model_validator(mode='after')
     def validate_openapi_tool_binding(self):
@@ -142,6 +148,10 @@ class McpToolBinding(BaseModel):
     source: str
     connections: Dict[str, str] | None
 
+class FlowToolBinding(BaseModel):
+    flow_id: str
+    model: Optional[dict] = None
+
 class ToolBinding(BaseModel):
     openapi: OpenApiToolBinding = None
     python: PythonToolBinding = None
@@ -149,6 +159,7 @@ class ToolBinding(BaseModel):
     skill: SkillToolBinding = None
     client_side: ClientSideToolBinding = None
     mcp: McpToolBinding = None
+    flow: FlowToolBinding = None
 
     @model_validator(mode='after')
     def validate_binding_type(self) -> 'ToolBinding':
@@ -158,7 +169,8 @@ class ToolBinding(BaseModel):
             self.wxflows is not None,
             self.skill is not None,
             self.client_side is not None,
-            self.mcp is not None
+            self.mcp is not None,
+            self.flow is not None
         ]
         if sum(bindings) == 0:
             raise ValueError("One binding must be set")
@@ -175,6 +187,7 @@ class ToolSpec(BaseModel):
     output_schema: ToolResponseBody = None
     binding: ToolBinding = None
     toolkit_id: str | None = None
+    is_async: bool = False
 
     def is_custom_join_tool(self) -> bool:
         if self.binding.python is None:

ibm_watsonx_orchestrate/cli/commands/agents/agents_command.py

@@ -137,7 +137,7 @@ def agent_create(
         List[str],
         typer.Option(
             "--knowledge-bases",
-            help="A list of knowlege bases names you wish for the agent to be able to utilise. Format --knowledge-bases base1 --knowledge-bases base2 ...",
+            help="A list of knowledge bases names you wish for the agent to be able to utilise. Format --knowledge-bases base1 --knowledge-bases base2 ...",
         ),
     ] = None,
     output_file: Annotated[
@@ -148,6 +148,21 @@ def agent_create(
             help="Write the agent definition out to a YAML (.yaml/.yml) file or a JSON (.json) file.",
         ),
     ] = None,
+    context_access_enabled: Annotated[
+        bool,
+        typer.Option(
+            "--context-access-enabled",
+            help="Whether the agent has access to context variables (default: True)",
+        ),
+    ] = True,
+    context_variables: Annotated[
+        List[str],
+        typer.Option(
+            "--context-variable",
+            "-v",
+            help="A list of context variable names the agent can access. Format: --context-variable var1 --context-variable var2 ... or -v var1 -v var2 ...",
+        ),
+    ] = None,
 ):
     chat_params_dict = json.loads(chat_params) if chat_params else {}
     config_dict = json.loads(config) if config else {}
@@ -177,6 +192,8 @@ def agent_create(
         nickname=nickname,
         app_id=app_id,
         output_file=output_file,
+        context_access_enabled=context_access_enabled,
+        context_variables=context_variables,
     )
     agents_controller.publish_or_update_agents([agent])