ibm-watsonx-orchestrate 1.0.0__py3-none-any.whl

ibm_watsonx_orchestrate/agent_builder/connections/types.py

@@ -0,0 +1,260 @@
+from pydantic import BaseModel, Field, AliasChoices, model_validator
+from typing import Optional, Union, TypeVar, List
+from enum import Enum
+
+class ConnectionKind(str, Enum):
+    basic = 'basic'
+    bearer = 'bearer'
+    api_key = 'api_key'
+    # 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_on_behalf_of_flow = 'oauth_auth_on_behalf_of_flow'
+    key_value = 'key_value'
+    kv = 'kv'
+
+    def __str__(self):
+        return self.value
+
+class ConnectionEnvironment(str, Enum):
+    DRAFT = 'draft'
+    LIVE = 'live'
+
+    def __str__(self):
+        return self.value
+
+class ConnectionPreference(str, Enum):
+    MEMBER = 'member'
+    TEAM = 'team'
+
+    def __str__(self):
+        return self.value
+
+class ConnectionAuthType(str, Enum):
+    # OAUTH2_AUTH_CODE = 'oauth2_auth_code'
+    # OAUTH2_IMPLICIT = 'oauth2_implicit'
+    # OAUTH2_PASSWORD = 'oauth2_password'
+    # OAUTH2_CLIENT_CREDS = 'oauth2_client_creds'
+    OAUTH_ON_BEHALF_OF_FLOW = 'oauth_on_behalf_of_flow'
+
+    def __str__(self):
+        return self.value 
+
+    def __repr__(self):
+        return repr(self.value)
+
+class ConnectionSecurityScheme(str, Enum):
+    BASIC_AUTH = 'basic_auth'
+    BEARER_TOKEN = 'bearer_token'
+    API_KEY_AUTH = 'api_key_auth'
+    OAUTH2 = 'oauth2'
+    KEY_VALUE = 'key_value_creds'
+    
+    def __str__(self):
+        return self.value 
+
+    def __repr__(self):
+        return repr(self.value)
+
+# Values for python tool expected credentials
+# Line up with what the Security_Schema env var is
+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_IMPLICIT = ConnectionAuthType.OAUTH2_IMPLICIT.value
+    # OAUTH2_PASSWORD = ConnectionAuthType.OAUTH2_PASSWORD.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
+
+    def __str__(self):
+        return self.value 
+
+    def __repr__(self):
+        return repr(self.value)
+
+OAUTH_CONNECTION_TYPES = {
+    # ConnectionType.OAUTH2_AUTH_CODE,
+    # ConnectionType.OAUTH2_CLIENT_CREDS,
+    # ConnectionType.OAUTH2_IMPLICIT,
+    # ConnectionType.OAUTH2_PASSWORD,
+    ConnectionType.OAUTH_ON_BEHALF_OF_FLOW,
+}
+
+class IdpConfigDataBody(BaseModel):
+    requested_token_use: str
+    requested_token_type: str
+
+class IdpConfigData(BaseModel):
+    header: Optional[dict] = None
+    body: IdpConfigDataBody
+
+    @model_validator(mode="after")
+    def set_default_values(self):
+        self.header = self.header or {
+            "content-type": "application/x-www-form-urlencoded"
+        }
+        return self
+
+class AppConfigData(BaseModel):
+    header: Optional[dict] = None
+    
+    @model_validator(mode="after")
+    def set_default_values(self):
+        self.header = self.header or {
+            "content-type": "application/x-www-form-urlencoded"
+        }
+        return self
+
+
+class ConnectionConfiguration(BaseModel):
+    app_id: str
+    environment: ConnectionEnvironment
+    preference: ConnectionPreference = Field(validation_alias=AliasChoices('preference', 'type'), serialization_alias='preference')
+    security_scheme: ConnectionSecurityScheme
+    auth_type: Optional[ConnectionAuthType] = None
+    sso: bool = False
+    server_url: str | None = None
+    idp_config_data: Optional[IdpConfigData] = Field(None, validation_alias=AliasChoices('idp_config_data', 'idp_config'), serialization_alias='idp_config_data')
+    app_config_data: Optional[AppConfigData] = Field(None, validation_alias=AliasChoices('app_config_data', 'app_config'), serialization_alias='app_config_data')
+    config_id: str = None
+    tenant_id: str = None
+
+    def __init__(self, *args, **kwargs):
+        kind = kwargs.get("kind")
+
+        if kind:
+            if not kwargs.get("auth_type"):
+                kwargs["auth_type"] = CONNECTION_KIND_OAUTH_TYPE_MAPPING.get(kind)
+        
+            if not kwargs.get("security_scheme"):
+                kwargs["security_scheme"] = CONNECTION_KIND_SCHEME_MAPPING.get(kind)
+        
+        super().__init__(*args, **kwargs)
+
+    @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.")
+        if self.sso:
+            if not self.idp_config_data:
+                raise ValueError("For SSO auth 'idp_config_data' is a required field")
+            if not self.app_config_data:
+                self.app_config_data = AppConfigData()
+        if self.security_scheme == ConnectionSecurityScheme.KEY_VALUE and self.preference == ConnectionPreference.MEMBER:
+            raise ValueError("Connection of type 'key_value' cannot be configured at the 'member' level. Key value connections must be of type 'team'")
+        return self
+
+class BasicAuthCredentials(BaseModel):
+    username: str
+    password: str
+    url: Optional[str] = None
+
+class BearerTokenAuthCredentials(BaseModel):
+    token: str
+    url: Optional[str] = None
+
+class APIKeyAuthCredentials(BaseModel):
+    api_key: str
+    url: Optional[str] = None
+
+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 OAuth2ImplicitCredentials(BaseModel):
+#     client_id: str
+#     authorization_url: str
+
+# class OAuth2PasswordCredentials(BaseModel):
+#     client_id: str
+#     client_secret: str
+#     token_url: str
+#     authorization_url: str
+
+# class OAuth2ClientCredentials(BaseModel):
+#     client_id: str
+#     client_secret: str
+#     token_url: str
+
+class OAuthOnBehalfOfCredentials(BaseModel):
+    client_id: str
+    access_token_url: str
+    grant_type: str
+
+# KeyValue is just an alias of dictionary
+class KeyValueConnectionCredentials(dict):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+    
+    def model_dump(self, *args, **kwargs):
+        return self
+
+CREDENTIALS_SET = Union[
+    BasicAuthCredentials,
+    BearerTokenAuthCredentials,
+    APIKeyAuthCredentials,
+    # OAuth2AuthCodeCredentials,
+    # OAuth2ImplicitCredentials,
+    # OAuth2PasswordCredentials,
+    # OAuth2ClientCredentials,
+    OAuthOnBehalfOfCredentials,
+    KeyValueConnectionCredentials
+]
+
+CREDENTIALS = TypeVar("CREDENTIALS", bound=CREDENTIALS_SET)
+
+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_implicit_flow: ConnectionSecurityScheme.OAUTH2,
+    # ConnectionKind.oauth_auth_password_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_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_on_behalf_of_flow: ConnectionAuthType.OAUTH_ON_BEHALF_OF_FLOW,
+}
+
+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.OAUTH_ON_BEHALF_OF_FLOW: OAuth2TokenCredentials,
+    ConnectionType.KEY_VALUE: KeyValueConnectionCredentials,
+}
+
+class IdentityProviderCredentials(BaseModel):
+    idp_url: str = Field(validation_alias=AliasChoices('idp_url', 'url'), serialization_alias='idp_url')
+    client_id: str
+    client_secret: str
+    scope: str
+    grant_type: str
+
+class ExpectedCredentials(BaseModel):
+    app_id: str
+    type: ConnectionType | List[ConnectionType]

ibm_watsonx_orchestrate/agent_builder/knowledge_bases/knowledge_base.py

@@ -0,0 +1,27 @@
+import json
+from ibm_watsonx_orchestrate.utils.utils import yaml_safe_load
+from .types import KnowledgeBaseSpec
+
+
+class KnowledgeBase(KnowledgeBaseSpec):
+
+    @staticmethod
+    def from_spec(file: str) -> 'KnowledgeBase':
+        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")
+            knowledge_base = KnowledgeBase.model_validate(content)
+
+        return knowledge_base
+    
+    def __repr__(self):
+        return f"KnowledgeBase(id='{self.id}', name='{self.name}', description='{self.description}')"
+
+    def __str__(self):
+        return self.__repr__()

ibm_watsonx_orchestrate/agent_builder/knowledge_bases/knowledge_base_requests.py

@@ -0,0 +1,59 @@
+import json
+from ibm_watsonx_orchestrate.utils.utils import yaml_safe_load
+from .types import CreateKnowledgeBase, PatchKnowledgeBase, KnowledgeBaseKind
+
+
+class KnowledgeBaseCreateRequest(CreateKnowledgeBase):
+
+    @staticmethod
+    def from_spec(file: str) -> 'CreateKnowledgeBase':
+        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 (content.get('documents') and content.get("conversational_search_tool", {}).get("index_config")) or \
+                  (not content.get('documents') and not content.get("conversational_search_tool", {}).get("index_config")):
+                raise ValueError("Must provide either \"documents\" or \"conversational_search_tool.index_config\", but not both")
+            
+            if not content.get("spec_version"):
+                raise ValueError(f"Field 'spec_version' not provided. Please ensure provided spec conforms to a valid spec format")
+            
+            if not content.get("kind"):
+                raise ValueError(f"Field 'kind' not provided. Should be 'knowledge_base'")
+
+            if content.get("kind") != KnowledgeBaseKind.KNOWLEDGE_BASE:
+                raise ValueError(f"Field 'kind' should be 'knowledge_base', but is set to '{content.get('kind')}'")
+            
+            knowledge_base = CreateKnowledgeBase.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")
+            
+            if not content.get("kind"):
+                raise ValueError(f"Field 'kind' not provided. Should be 'knowledge_base'")
+
+            if content.get("kind") != KnowledgeBaseKind.KNOWLEDGE_BASE:
+                raise ValueError(f"Field 'kind' should be 'knowledge_base', but is set to '{content.get('kind')}'")
+            
+            patch = PatchKnowledgeBase.model_validate(content)
+
+        return patch

ibm_watsonx_orchestrate/agent_builder/knowledge_bases/types.py

@@ -0,0 +1,243 @@
+from typing import Optional
+from datetime import datetime
+from uuid import UUID
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+
+class SpecVersion(str, Enum):
+    V1 = "v1"
+
+class KnowledgeBaseKind(str, Enum):
+    KNOWLEDGE_BASE = "knowledge_base"
+class RetrievalConfidenceThreshold(str, Enum):
+    Lowest = "Lowest"
+    Low = "Low"
+    High = "High"
+    Highest = "Highest"
+
+
+class GeneratedResponseLength(str, Enum):
+    Concise = "Concise"
+    Moderate = "Moderate"
+    Verbose = "Verbose"
+
+
+class ResponseConfidenceThreshold(str, Enum):
+    Lowest = "Lowest"
+    Low = "Low"
+    High = "High"
+    Highest = "Highest"
+
+class KnowledgeBaseRepresentation(str, Enum):
+    auto = "auto"
+    tool = "tool"
+
+class ConfidenceThresholds(BaseModel):
+    retrieval_confidence_threshold: Optional[RetrievalConfidenceThreshold] = None
+    response_confidence_threshold: Optional[ResponseConfidenceThreshold] = None
+
+class CitationsConfig(BaseModel):
+    """
+    example:
+    {
+        "citation_title": "how do i know",
+        "citations_shown": 5,
+    }
+    """
+    citation_title: Optional[str] = None
+    citations_shown: Optional[int] = None
+
+
+class HAPFilteringConfig(BaseModel):
+    enabled: Optional[bool] = None
+    threshold: Optional[float] = None
+
+
+class HAPFiltering(BaseModel):
+    """
+    example
+    {
+        "output": {
+            "enabled": True,
+            "threshold": 0.7,
+        }
+    }
+
+    """
+    output: Optional[HAPFilteringConfig] = None
+
+class QueryRewriteConfig(BaseModel):
+    """
+    example
+
+    {
+        "enabled": True,
+        "model_id": "meta-llama/llama-3-1-70b-instruct"
+    }
+
+    """
+    enabled: Optional[bool] = None
+    model_id: Optional[str] = None
+
+class GenerationConfiguration(BaseModel):
+    """
+    example
+    {
+        "model_id": "meta-llama/llama-3-1-70b-instruct",
+        "prompt_instruction": "When the documents are in different languages, you should respond in english.",
+        "retrieval_confidence_threshold": "Lowest",
+        "generated_response_length": "Moderate",
+        "response_confidence_threshold": "Low",
+        "display_text_no_results_found": "no docs found",
+        "display_text_connectivity_issue": "conn failed",
+    }
+    """
+
+    model_id: Optional[str] = None
+    prompt_instruction: Optional[str] = None
+    generated_response_length: Optional[GeneratedResponseLength] = None
+    display_text_no_results_found: Optional[str] = None
+    display_text_connectivity_issue: Optional[str] = None
+
+class FieldMapping(BaseModel):
+    """
+    example
+
+    {
+        "title": "title",
+        "body": "text",
+        "url": "some-url"
+    }
+    """
+    title: Optional[str] = None
+    body: Optional[str] = None
+    url: Optional[str] = None
+
+class MilvusConnection(BaseModel):
+    """
+    example:
+    {
+        "grpc_host": "https://xxxx.lakehouse.appdomain.cloud",
+        "database": "test_db",
+        "collection": "search_wa_docs",
+        "index": "dense",
+        "embedding_model_id": "sentence-transformers/all-minilm-l12-v2",
+        "grpc_port": "30564",
+        "filter": "title like \"%action%\"",
+        "limit": 10,
+        "field_mapping": {
+                        "title": "title",
+                        "body": "text",
+                        "url": "some-url"
+                    }
+    }
+    """
+    grpc_host: Optional[str] = None
+    database: Optional[str] = None
+    collection: Optional[str] = None
+    index: Optional[str] = None
+    embedding_model_id: Optional[str] = None
+    limit : Optional[int] = None
+    grpc_port: Optional[str] = None
+    filter: Optional[str] = None
+    field_mapping: Optional[FieldMapping] = None
+
+
+class ElasticSearchConnection(BaseModel):
+    """
+    example:
+
+    {
+        "url": "https://xxxx.databases.appdomain.cloud",
+        "index": "search-wa-docs",
+        "port": "31871",
+        "query_body": {"size":5,"query":{"text_expansion":{"ml.tokens":{"model_id":".elser_model_2_linux-x86_64","model_text": "$QUERY"}}}},
+        "result_filter": [
+                            {
+                                "match": {
+                                    "title": "A_keyword_in_title"
+                                }
+                            },
+                            {
+                                "match": {
+                                    "text": "A_keyword_in_text"
+                                }
+                            },
+                            {
+                                "match": {
+                                    "id": "A_specific_ID"
+                                }
+                            }
+                        ] = None,
+        "field_mapping": {
+                        "title": "title",
+                        "body": "text",
+                        "url": "some-url"
+                    }
+    }
+    """
+    url: Optional[str] = None
+    index: Optional[str] = None
+    port: Optional[str] = None
+    query_body: Optional[dict] = None
+    result_filter: Optional[list] = None 
+    field_mapping: Optional[FieldMapping] = None
+
+
+class IndexConnection(BaseModel):
+    connection_id: Optional[str] = None
+    milvus: Optional[MilvusConnection] = None
+    elastic_search: Optional[ElasticSearchConnection] = None
+
+    
+class ConversationalSearchConfig(BaseModel):
+    language: Optional[str] = None
+    index_config: list[IndexConnection] = None
+    generation: Optional[GenerationConfiguration] = None
+    query_rewrite: Optional[QueryRewriteConfig] = None
+    citations: Optional[CitationsConfig] = None
+    hap_filtering: Optional[HAPFiltering] = None
+    confidence_thresholds: Optional[ConfidenceThresholds] = None
+
+class KnowledgeBaseBuiltInVectorIndexConfig(BaseModel):
+    chunk_size: Optional[int] = None
+    chunk_overlap: Optional[int] = None
+    limit: Optional[int] = None
+    
+class CreateKnowledgeBase(BaseModel):
+    """request payload schema"""
+    name: Optional[str] = None
+    description: Optional[str] = None
+    documents: list[str] = None
+    vector_index: Optional[KnowledgeBaseBuiltInVectorIndexConfig] = None
+    conversational_search_tool: Optional[ConversationalSearchConfig] = None
+    prioritize_built_in_index: Optional[bool] = 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
+    
+    
+class KnowledgeBaseSpec(BaseModel):
+    """Schema for a complete knowledge-base."""
+    spec_version: SpecVersion = None
+    kind: KnowledgeBaseKind = KnowledgeBaseKind.KNOWLEDGE_BASE
+    id: Optional[UUID] = None 
+    tenant_id: Optional[str] = None
+    name: Optional[str] = None
+    description: Optional[str] = None
+    vector_index: Optional[KnowledgeBaseBuiltInVectorIndexConfig] = None
+    conversational_search_tool: Optional[ConversationalSearchConfig] | Optional[UUID] = None
+    prioritize_built_in_index: Optional[bool] = None
+    vector_index_id: Optional[UUID] = None 
+    created_by: Optional[str] = None
+    created_on: Optional[datetime] = None 
+    updated_at: Optional[datetime] = None
+

ibm_watsonx_orchestrate/agent_builder/tools/__init__.py

@@ -0,0 +1,4 @@
+from .base_tool import BaseTool
+from .python_tool import tool, PythonTool, get_all_python_tools
+from .openapi_tool import create_openapi_json_tool, create_openapi_json_tool_from_uri, create_openapi_json_tools_from_uri, OpenAPITool, HTTPException
+from .types import ToolPermission, JsonSchemaObject, ToolRequestBody, ToolResponseBody, OpenApiSecurityScheme, OpenApiToolBinding, PythonToolBinding, WxFlowsToolBinding, SkillToolBinding, ClientSideToolBinding, ToolBinding, ToolSpec

ibm_watsonx_orchestrate/agent_builder/tools/base_tool.py

@@ -0,0 +1,36 @@
+import json
+
+import yaml
+
+from .types import ToolSpec
+
+
+class BaseTool:
+    __tool_spec__: ToolSpec
+
+    def __init__(self, spec: ToolSpec):
+        self.__tool_spec__ = spec
+
+    def __call__(self, **kwargs):
+        pass
+
+    def dump_spec(self, file: str) -> None:
+        dumped = self.__tool_spec__.model_dump(mode='json', exclude_unset=True, exclude_none=True, by_alias=True)
+        with open(file, 'w') as f:
+            if file.endswith('.yaml') or file.endswith('.yml'):
+                yaml.dump(dumped, f)
+            elif file.endswith('.json'):
+                json.dump(dumped, f, indent=2)
+            else:
+                raise ValueError('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)
+        return json.dumps(dumped, indent=2)
+
+    def to_langchain_tool(self):
+        from .integrations.langchain import as_langchain_tool
+        return as_langchain_tool(self)
+
+    def __repr__(self):
+        return f"Tool(name='{self.__tool_spec__.name}', description='{self.__tool_spec__.description}')"