ibm-watsonx-orchestrate 1.6.1__py3-none-any.whl → 1.7.0__py3-none-any.whl

ibm_watsonx_orchestrate/__init__.py

@@ -5,7 +5,8 @@
 
 pkg_name = "ibm-watsonx-orchestrate"
 
-__version__ = "1.6.1"
+__version__ = "1.7.0"
+
 
 
 

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,6 +9,7 @@ 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
 
@@ -63,7 +64,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)
@@ -136,7 +137,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 +145,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 +198,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 +206,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 +251,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 +259,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/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
@@ -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,7 +200,7 @@ 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])
@@ -260,23 +261,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
 

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