ibm-watsonx-orchestrate 1.7.0a0__py3-none-any.whl → 1.7.0b1__py3-none-any.whl

ibm_watsonx_orchestrate/agent_builder/tools/python_tool.py

@@ -5,9 +5,6 @@ import os
 from typing import Any, Callable, Dict, List, get_type_hints
 import logging
 
-import docstring_parser
-from langchain_core.tools.base import create_schema_from_function
-from langchain_core.utils.json_schema import dereference_refs
 from pydantic import TypeAdapter, BaseModel
 
 from ibm_watsonx_orchestrate.utils.utils import yaml_safe_load
@@ -15,6 +12,7 @@ from ibm_watsonx_orchestrate.agent_builder.connections import ExpectedCredential
 from .base_tool import BaseTool
 from .types import PythonToolKind, ToolSpec, ToolPermission, ToolRequestBody, ToolResponseBody, JsonSchemaObject, ToolBinding, \
     PythonToolBinding
+from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 
 _all_tools = []
 logger = logging.getLogger(__name__)
@@ -25,15 +23,136 @@ JOIN_TOOL_PARAMS = {
     'messages': List[Dict[str, Any]],
 }
 
+def _parse_expected_credentials(expected_credentials: ExpectedCredentials | dict):
+    parsed_expected_credentials = []
+    if expected_credentials:
+        for credential in expected_credentials:
+            if isinstance(credential, ExpectedCredentials):
+                parsed_expected_credentials.append(credential)
+            else:
+                parsed_expected_credentials.append(ExpectedCredentials.model_validate(credential))
+    
+    return parsed_expected_credentials
+
 class PythonTool(BaseTool):
-    def __init__(self, fn, spec: ToolSpec, expected_credentials: List[ExpectedCredentials]=None):
-        BaseTool.__init__(self, spec=spec)
+    def __init__(self,
+                fn,
+                name: str = None,
+                description: str = None,
+                input_schema: ToolRequestBody = None,
+                output_schema: ToolResponseBody = None,
+                permission: ToolPermission = ToolPermission.READ_ONLY,
+                expected_credentials: List[ExpectedCredentials] = None,
+                display_name: str = None,
+                kind: PythonToolKind = PythonToolKind.TOOL,
+                spec=None
+                ):
         self.fn = fn
-        self.expected_credentials=expected_credentials
+        self.name = name
+        self.description = description
+        self.input_schema = input_schema
+        self.output_schema = output_schema
+        self.permission = permission
+        self.display_name = display_name
+        self.kind = kind
+        self.expected_credentials=_parse_expected_credentials(expected_credentials)
+        self._spec = None
+        if spec:
+            self._spec = spec
 
     def __call__(self, *args, **kwargs):
         return self.fn(*args, **kwargs)
+    
+    @property
+    def __tool_spec__(self):
+        if self._spec:
+            return self._spec
+        
+        import docstring_parser
+        from langchain_core.tools.base import create_schema_from_function
+        from langchain_core.utils.json_schema import dereference_refs
+
+        if self.fn.__doc__ is not None:
+            doc = docstring_parser.parse(self.fn.__doc__)
+        else:
+            doc = None
+
+        _desc = self.description
+        if self.description is None and doc is not None:
+            _desc = doc.description
+
+        
+        spec = ToolSpec(
+            name=self.name or self.fn.__name__,
+            display_name=self.display_name,
+            description=_desc,
+            permission=self.permission
+        )
+
+        spec.binding = ToolBinding(python=PythonToolBinding(function=''))
+
+        linux_friendly_os_cwd = os.getcwd().replace("\\", "/")
+        function_binding = (inspect.getsourcefile(self.fn)
+                            .replace("\\", "/")
+                            .replace(linux_friendly_os_cwd+'/', '')
+                            .replace('.py', '')
+                            .replace('/','.') +
+                            f":{self.fn.__name__}")
+        spec.binding.python.function = function_binding
+
+        sig = inspect.signature(self.fn)
+        
+        # If the function is a join tool, validate its signature matches the expected parameters. If not, raise error with details.
+        if self.kind == PythonToolKind.JOIN_TOOL:
+            _validate_join_tool_func(self.fn, sig, spec.name)
+
+        if not self.input_schema:
+            try:
+                input_schema_model: type[BaseModel] = create_schema_from_function(spec.name, self.fn, parse_docstring=True)
+            except:
+                logger.warning("Unable to properly parse parameter descriptions due to incorrectly formatted docstring. This may result in degraded agent performance. To fix this, please ensure the docstring conforms to Google's docstring format.")
+                input_schema_model: type[BaseModel] = create_schema_from_function(spec.name, self.fn, parse_docstring=False)
+            input_schema_json = input_schema_model.model_json_schema()
+            input_schema_json = dereference_refs(input_schema_json)
+
+            # Convert the input schema to a JsonSchemaObject
+            input_schema_obj = JsonSchemaObject(**input_schema_json)
+            input_schema_obj = _fix_optional(input_schema_obj)
+
+            spec.input_schema = ToolRequestBody(
+                type='object',
+                properties=input_schema_obj.properties or {},
+                required=input_schema_obj.required or []
+            )
+        else:
+            spec.input_schema = self.input_schema
+        
+        _validate_input_schema(spec.input_schema)
+
+        if not self.output_schema:
+            ret = sig.return_annotation
+            if ret != sig.empty:
+                _schema = dereference_refs(TypeAdapter(ret).json_schema())
+                if '$defs' in _schema:
+                    _schema.pop('$defs')
+                spec.output_schema = _fix_optional(ToolResponseBody(**_schema))
+            else:
+                spec.output_schema = ToolResponseBody()
+
+            if doc is not None and doc.returns is not None and doc.returns.description is not None:
+                spec.output_schema.description = doc.returns.description
+
+        else:
+            spec.output_schema = ToolResponseBody()
+        
+         # Validate the generated schema still conforms to the requirement for a join tool
+        if self.kind == PythonToolKind.JOIN_TOOL:
+            if not spec.is_custom_join_tool():
+                raise ValueError(f"Join tool '{spec.name}' does not conform to the expected join tool schema. Please ensure the input schema has the required fields: {JOIN_TOOL_PARAMS.keys()} and the output schema is a string.")
 
+        self._spec = spec
+        return spec
+    
     @staticmethod
     def from_spec(file: str) -> 'PythonTool':
         with open(file, 'r') as f:
@@ -42,10 +161,10 @@ class PythonTool(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.python is None:
-            raise ValueError('failed to load python tool as the tool had no python binding')
+            raise BadRequest('failed to load python tool as the tool had no python binding')
 
         [module, fn_name] = spec.binding.python.function.split(':')
         fn = getattr(importlib.import_module(module), fn_name)
@@ -147,92 +266,17 @@ def tool(
     """
     # inspiration: https://github.com/pydantic/pydantic/blob/main/pydantic/validate_call_decorator.py
     def _tool_decorator(fn):
-        if fn.__doc__ is not None:
-            doc = docstring_parser.parse(fn.__doc__)
-        else:
-            doc = None
-
-        _desc = description
-        if description is None and doc is not None:
-            _desc = doc.description
-
-        
-        spec = ToolSpec(
-            name=name or fn.__name__,
+        t = PythonTool(
+            fn=fn,
+            name=name,
+            description=description,
+            input_schema=input_schema,
+            output_schema=output_schema,
+            permission=permission,
+            expected_credentials=expected_credentials,
             display_name=display_name,
-            description=_desc,
-            permission=permission
+            kind=kind
         )
-
-        parsed_expected_credentials = []
-        if expected_credentials:
-            for credential in expected_credentials:
-                if isinstance(credential, ExpectedCredentials):
-                    parsed_expected_credentials.append(credential)
-                else:
-                    parsed_expected_credentials.append(ExpectedCredentials.model_validate(credential))
-        
-        t = PythonTool(fn=fn, spec=spec, expected_credentials=parsed_expected_credentials)
-        spec.binding = ToolBinding(python=PythonToolBinding(function=''))
-
-        linux_friendly_os_cwd = os.getcwd().replace("\\", "/")
-        function_binding = (inspect.getsourcefile(fn)
-                            .replace("\\", "/")
-                            .replace(linux_friendly_os_cwd+'/', '')
-                            .replace('.py', '')
-                            .replace('/','.') +
-                            f":{fn.__name__}")
-        spec.binding.python.function = function_binding
-
-        sig = inspect.signature(fn)
-        
-        # If the function is a join tool, validate its signature matches the expected parameters. If not, raise error with details.
-        if kind == PythonToolKind.JOIN_TOOL:
-            _validate_join_tool_func(fn, sig, spec.name)
-        
-        if not input_schema:
-            try:
-                input_schema_model: type[BaseModel] = create_schema_from_function(spec.name, fn, parse_docstring=True)
-            except:
-                logger.warning("Unable to properly parse parameter descriptions due to incorrectly formatted docstring. This may result in degraded agent performance. To fix this, please ensure the docstring conforms to Google's docstring format.")
-                input_schema_model: type[BaseModel] = create_schema_from_function(spec.name, fn, parse_docstring=False)
-            input_schema_json = input_schema_model.model_json_schema()
-            input_schema_json = dereference_refs(input_schema_json)
-
-            # Convert the input schema to a JsonSchemaObject
-            input_schema_obj = JsonSchemaObject(**input_schema_json)
-            input_schema_obj = _fix_optional(input_schema_obj)
-
-            spec.input_schema = ToolRequestBody(
-                type='object',
-                properties=input_schema_obj.properties or {},
-                required=input_schema_obj.required or []
-            )
-        else:
-            spec.input_schema = input_schema
-        
-        _validate_input_schema(spec.input_schema)
-
-        if not output_schema:
-            ret = sig.return_annotation
-            if ret != sig.empty:
-                _schema = dereference_refs(TypeAdapter(ret).json_schema())
-                if '$defs' in _schema:
-                    _schema.pop('$defs')
-                spec.output_schema = _fix_optional(ToolResponseBody(**_schema))
-            else:
-                spec.output_schema = ToolResponseBody()
-
-            if doc is not None and doc.returns is not None and doc.returns.description is not None:
-                spec.output_schema.description = doc.returns.description
-
-        else:
-            spec.output_schema = ToolResponseBody()
-        
-        # Validate the generated schema still conforms to the requirement for a join tool
-        if kind == PythonToolKind.JOIN_TOOL:
-            if not spec.is_custom_join_tool():
-                raise ValueError(f"Join tool '{spec.name}' does not conform to the expected join tool schema. Please ensure the input schema has the required fields: {JOIN_TOOL_PARAMS.keys()} and the output schema is a string.")
             
         _all_tools.append(t)
         return t

ibm_watsonx_orchestrate/agent_builder/tools/types.py

@@ -2,6 +2,7 @@ from enum import Enum
 from typing import List, Any, Dict, Literal, Optional, Union
 
 from pydantic import BaseModel, model_validator, ConfigDict, Field, AliasChoices
+from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 
 
 class ToolPermission(str, Enum):
@@ -74,19 +75,19 @@ class OpenApiSecurityScheme(BaseModel):
     @model_validator(mode='after')
     def validate_security_scheme(self) -> 'OpenApiSecurityScheme':
         if self.type == 'http' and self.scheme is None:
-            raise ValueError("'scheme' is required when type is 'http'")
+            raise BadRequest("'scheme' is required when type is 'http'")
 
         if self.type == 'oauth2' and self.flows is None:
-            raise ValueError("'flows' is required when type is 'oauth2'")
+            raise BadRequest("'flows' is required when type is 'oauth2'")
 
         if self.type == 'openIdConnect' and self.open_id_connect_url is None:
-            raise ValueError("'open_id_connect_url' is required when type is 'openIdConnect'")
+            raise BadRequest("'open_id_connect_url' is required when type is 'openIdConnect'")
 
         if self.type == 'apiKey':
             if self.name is None:
-                raise ValueError("'name' is required when type is 'apiKey'")
+                raise BadRequest("'name' is required when type is 'apiKey'")
             if self.in_field is None:
-                raise ValueError("'in_field' is required when type is 'apiKey'")
+                raise BadRequest("'in_field' is required when type is 'apiKey'")
 
         return self
 
@@ -111,7 +112,7 @@ class OpenApiToolBinding(BaseModel):
     @model_validator(mode='after')
     def validate_openapi_tool_binding(self):
         if len(self.servers) != 1:
-            raise ValueError("OpenAPI definition must include exactly one server")
+            raise BadRequest("OpenAPI definition must include exactly one server")
         return self
 
 
@@ -129,7 +130,7 @@ class WxFlowsToolBinding(BaseModel):
     @model_validator(mode='after')
     def validate_security_scheme(self) -> 'WxFlowsToolBinding':
         if self.security.type != 'apiKey':
-            raise ValueError("'security' scheme must be of type 'apiKey'")
+            raise BadRequest("'security' scheme must be of type 'apiKey'")
         return self
 
 
@@ -173,9 +174,9 @@ class ToolBinding(BaseModel):
             self.flow is not None
         ]
         if sum(bindings) == 0:
-            raise ValueError("One binding must be set")
+            raise BadRequest("One binding must be set")
         if sum(bindings) > 1:
-            raise ValueError("Only one binding can be set")
+            raise BadRequest("Only one binding can be set")
         return self
 
 class ToolSpec(BaseModel):

ibm_watsonx_orchestrate/cli/commands/agents/agents_command.py

@@ -31,6 +31,13 @@ def agent_create(
         str,
         typer.Option("--name", "-n", help="Name of the agent you wish to create"),
     ],
+    description: Annotated[
+        str,
+        typer.Option(
+            "--description",
+            help="Description of the agent",
+        ),
+    ],
     title: Annotated[
         str,
         typer.Option("--title", "-t", help="Title of the agent you wish to create. Only needed for External and Assistant Agents"),
@@ -87,13 +94,6 @@ def agent_create(
         str,
         typer.Option("--app-id", help="Application ID for the agent"),
     ] = None,
-    description: Annotated[
-        str,
-        typer.Option(
-            "--description",
-            help="Description of the agent",
-        ),
-    ] = None,
     llm: Annotated[
         str,
         typer.Option(

ibm_watsonx_orchestrate/cli/commands/agents/agents_controller.py

@@ -29,6 +29,7 @@ from ibm_watsonx_orchestrate.client.agents.agent_client import AgentClient, Agen
 from ibm_watsonx_orchestrate.client.agents.external_agent_client import ExternalAgentClient
 from ibm_watsonx_orchestrate.client.agents.assistant_agent_client import AssistantAgentClient
 from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
+from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 from ibm_watsonx_orchestrate.client.connections import get_connections_client
 from ibm_watsonx_orchestrate.client.knowledge_bases.knowledge_base_client import KnowledgeBaseClient
 
@@ -71,7 +72,7 @@ def create_agent_from_spec(file:str, kind:str) -> Agent | ExternalAgent | Assist
         case AgentKind.ASSISTANT:
             agent = AssistantAgent.from_spec(file)
         case _:
-            raise ValueError("'kind' must be either 'native' or 'external'")
+            raise BadRequest("'kind' must be either 'native' or 'external'")
 
     return agent
 
@@ -88,7 +89,7 @@ def parse_file(file: str) -> List[Agent | ExternalAgent | AssistantAgent]:
         agents = import_python_agent(file)
         return agents
     else:
-        raise ValueError("file must end in .json, .yaml, .yml or .py")
+        raise BadRequest("file must end in .json, .yaml, .yml or .py")
 
 def parse_create_native_args(name: str, kind: AgentKind, description: str | None, **args) -> dict:
     agent_details = {
@@ -747,14 +748,25 @@ class AgentsController:
         return knowledge_bases
 
     def list_agents(self, kind: AgentKind=None, verbose: bool=False):
+        parse_errors = []
+
         if kind == AgentKind.NATIVE or kind is None:
             response = self.get_native_client().get()
-            native_agents = [Agent.model_validate(agent) for agent in response]
+            native_agents = []
+            for agent in response:
+                try:
+                    native_agents.append(Agent.model_validate(agent))
+                except Exception as e:
+                    name = agent.get('name', None)
+                    parse_errors.append([
+                        f"Agent '{name}' could not be parsed",
+                        json.dumps(agent),
+                        e
+                    ])
 
             if verbose:
                 agents_list = []
                 for agent in native_agents:
-
                     agents_list.append(json.loads(agent.dumps_spec()))
 
                 rich.print(rich.json.JSON(json.dumps(agents_list, indent=4)))
@@ -799,7 +811,13 @@ class AgentsController:
         if kind == AgentKind.EXTERNAL or kind is None:
             response = self.get_external_client().get()
 
-            external_agents = [ExternalAgent.model_validate(agent) for agent in response]
+            external_agents = []
+            for agent in response:
+                try:
+                    external_agents.append(ExternalAgent.model_validate(agent))
+                except Exception as e:
+                    name = agent.get('name', None)
+                    parse_errors.append([f"External Agent {name} could not be parsed", e])
 
             response_dict = {agent["id"]: agent for agent in response}
 
@@ -859,7 +877,13 @@ class AgentsController:
         if kind == AgentKind.ASSISTANT or kind is None:
             response = self.get_assistant_client().get()
 
-            assistant_agents = [AssistantAgent.model_validate(agent) for agent in response]
+            assistant_agents = []
+            for agent in response:
+                try:
+                    assistant_agents.append(AssistantAgent.model_validate(agent))
+                except Exception as e:
+                    name = agent.get('name', None)
+                    parse_errors.append([f"Assistant Agent {name} could not be parsed", e])
 
             response_dict = {agent["id"]: agent for agent in response}
 
@@ -914,6 +938,10 @@ class AgentsController:
                     )
                 rich.print(assistants_table)
 
+        for error in parse_errors:
+            for l in error:
+                logger.error(l)
+
     def remove_agent(self, name: str, kind: AgentKind):
         try:
             if kind == AgentKind.NATIVE:
@@ -923,7 +951,7 @@ class AgentsController:
             elif kind == AgentKind.ASSISTANT:
                 client = self.get_assistant_client()
             else:
-                raise ValueError("'kind' must be 'native'")
+                raise BadRequest("'kind' must be 'native'")
 
             draft_agents = client.get_draft_by_name(name)
             if len(draft_agents) > 1:

ibm_watsonx_orchestrate/cli/commands/chat/chat_command.py

@@ -24,6 +24,8 @@ def chat_start(
         url = "http://localhost:3000/chat-lite"
         webbrowser.open(url)
         logger.info(f"Opening chat interface at {url}")
+        # TODO: Remove when connections UI is added
+        logger.warning("When using local chat, requests that the user 'Connect Apps' must be resolved by running `orchestrate connections set-credentials`")
     else:
         logger.error("Unable to start orchestrate UI chat service.  Please check error messages and logs")
 

ibm_watsonx_orchestrate/cli/commands/connections/connections_controller.py

@@ -346,7 +346,7 @@ def add_connection(app_id: str) -> None:
         status_code = response.status_code
         try:
             if status_code == 409:
-                response_text = f"Failed to create connection. A connection with the App ID '{app_id}' already exists. Please select a diffrent App ID or delete the existing resource."
+                response_text = f"Failed to create connection. A connection with the App ID '{app_id}' already exists. Please select a different App ID or delete the existing resource."
             else:
                 resp = json.loads(response_text)
                 response_text = resp.get('detail')
@@ -370,12 +370,14 @@ def remove_connection(app_id: str) -> None:
 
 def list_connections(environment: ConnectionEnvironment | None, verbose: bool = False) -> None:
     client = get_connections_client()
-
     connections = client.list()
-    
+    is_local = is_local_dev()
+
     if verbose:
         connections_list = []
         for conn in connections:
+            if is_local and  conn.environment == ConnectionEnvironment.LIVE:
+                continue
             connections_list.append(json.loads(conn.model_dump_json()))
 
         rich.print_json(json.dumps(connections_list, indent=4))
@@ -414,7 +416,7 @@ def list_connections(environment: ConnectionEnvironment | None, verbose: bool =
                     conn.preference,
                     "✅" if conn.credentials_entered else "❌"
                 )
-            elif conn.environment == ConnectionEnvironment.LIVE:
+            elif conn.environment == ConnectionEnvironment.LIVE and not is_local:
                 live_table.add_row(
                     conn.app_id,
                     connection_type,

ibm_watsonx_orchestrate/cli/commands/environment/environment_controller.py

@@ -23,7 +23,7 @@ from ibm_watsonx_orchestrate.cli.config import (
 )
 from ibm_watsonx_orchestrate.client.client import Client
 from ibm_watsonx_orchestrate.client.client_errors import ClientError
-from ibm_watsonx_orchestrate.client.agents.agent_client import AgentClient, ClientAPIException
+from ibm_watsonx_orchestrate.client.knowledge_bases.knowledge_base_client import KnowledgeBaseClient, ClientAPIException
 from ibm_watsonx_orchestrate.client.credentials import Credentials
 from threading import Lock
 from ibm_watsonx_orchestrate.client.utils import is_local_dev, check_token_validity, is_cpd_env
@@ -55,13 +55,13 @@ def _validate_token_functionality(token: str, url: str) -> None:
     '''
     is_cpd = is_cpd_env(url)
     if is_cpd is True:
-        agent_client = AgentClient(base_url=url, api_key=token, is_local=is_local_dev(url), verify=False)
+        knowledge_base_client = KnowledgeBaseClient(base_url=url, api_key=token, is_local=is_local_dev(url), verify=False)
     else:
-        agent_client = AgentClient(base_url=url, api_key=token, is_local=is_local_dev(url))
-    agent_client.api_key = token
+        knowledge_base_client = KnowledgeBaseClient(base_url=url, api_key=token, is_local=is_local_dev(url))
+    knowledge_base_client.api_key = token
 
     try:
-        agent_client.get()
+        knowledge_base_client.get()
     except ClientAPIException as e:
         if e.response.status_code >= 400:
             reason = e.response.reason
@@ -167,7 +167,7 @@ def activate(name: str, apikey: str=None, username: str=None, password: str=None
 
 def add(name: str, url: str, should_activate: bool=False, iam_url: str=None, type: EnvironmentAuthType=None, insecure: bool=None, verify: str=None) -> None:
     if name == PROTECTED_ENV_NAME:
-        logger.error(f"The name '{PROTECTED_ENV_NAME}' is a reserved environment name. Please select a diffrent name or use `orchestrate env activate {PROTECTED_ENV_NAME}` to swap to '{PROTECTED_ENV_NAME}'")
+        logger.error(f"The name '{PROTECTED_ENV_NAME}' is a reserved environment name. Please select a different name or use `orchestrate env activate {PROTECTED_ENV_NAME}` to swap to '{PROTECTED_ENV_NAME}'")
         return
 
     cfg = Config()

ibm_watsonx_orchestrate/cli/commands/environment/types.py

@@ -4,6 +4,8 @@ from enum import Enum
 class EnvironmentAuthType(str, Enum):
     IBM_CLOUD_IAM = 'ibm_iam'
     MCSP = 'mcsp'
+    MCSP_V1 = 'mcsp_v1'
+    MCSP_V2 = 'mcsp_v2'
     CPD = 'cpd'
 
     def __str__(self):