airia 0.1.26__py3-none-any.whl → 0.1.27__py3-none-any.whl

airia/client/async_client.py

@@ -21,6 +21,7 @@ from .pipeline_import import AsyncPipelineImport
 from .pipelines_config import AsyncPipelinesConfig
 from .project import AsyncProject
 from .store import AsyncStore
+from .tools import AsyncTools
 
 
 class AiriaAsyncClient(AiriaBaseClient):
@@ -74,6 +75,7 @@ class AiriaAsyncClient(AiriaBaseClient):
         self.data_vector_search = AsyncDataVectorSearch(self._request_handler)
         self.library = AsyncLibrary(self._request_handler)
         self.models = AsyncModels(self._request_handler)
+        self.tools = AsyncTools(self._request_handler)
 
     @classmethod
     def with_openai_gateway(

airia/client/pipelines_config/async_pipelines_config.py

@@ -188,3 +188,53 @@ class AsyncPipelinesConfig(BasePipelinesConfig):
         resp = await self._request_handler.make_request("GET", request_data)
 
         return GetPipelinesConfigResponse(**resp)
+
+    async def delete_pipeline(
+        self,
+        pipeline_id: str,
+        correlation_id: Optional[str] = None,
+    ) -> None:
+        """
+        Delete a pipeline by its ID.
+
+        This method permanently removes a pipeline and all its configuration
+        from the Airia platform. This action cannot be undone.
+
+        Args:
+            pipeline_id (str): The unique identifier of the pipeline to delete.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+
+        Returns:
+            None: This method returns nothing upon successful deletion (204 No Content).
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The pipeline_id doesn't exist (404)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaAsyncClient
+
+            client = AiriaAsyncClient(api_key="your_api_key")
+
+            # Delete a pipeline
+            await client.pipelines_config.delete_pipeline(
+                pipeline_id="your_pipeline_id"
+            )
+            print("Pipeline deleted successfully")
+            ```
+
+        Warning:
+            This operation is permanent and cannot be reversed. Ensure you have
+            the correct pipeline_id before calling this method.
+        """
+        request_data = self._pre_delete_pipeline(
+            pipeline_id=pipeline_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        await self._request_handler.make_request("DELETE", request_data, return_json=False)

airia/client/pipelines_config/base_pipelines_config.py

@@ -114,3 +114,40 @@ class BasePipelinesConfig:
         )
 
         return request_data
+
+    def _pre_delete_pipeline(
+        self,
+        pipeline_id: str,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        """
+        Prepare request data for deleting a pipeline by ID.
+
+        This internal method constructs the URL for pipeline deletion
+        requests using the provided pipeline identifier.
+
+        Args:
+            pipeline_id: ID of the pipeline to delete
+            correlation_id: Optional correlation ID for tracing
+            api_version: API version to use for the request
+
+        Returns:
+            RequestData: Prepared request data for the pipeline deletion endpoint
+
+        Raises:
+            ValueError: If an invalid API version is provided
+        """
+        if api_version not in ApiVersion.as_list():
+            raise ValueError(
+                f"Invalid API version: {api_version}. Valid versions are: {', '.join(ApiVersion.as_list())}"
+            )
+        url = urljoin(
+            self._request_handler.base_url,
+            f"{api_version}/PipelinesConfig/{pipeline_id}",
+        )
+        request_data = self._request_handler.prepare_request(
+            url, correlation_id=correlation_id
+        )
+
+        return request_data

airia/client/pipelines_config/sync_pipelines_config.py

@@ -188,3 +188,53 @@ class PipelinesConfig(BasePipelinesConfig):
         resp = self._request_handler.make_request("GET", request_data)
 
         return GetPipelinesConfigResponse(**resp)
+
+    def delete_pipeline(
+        self,
+        pipeline_id: str,
+        correlation_id: Optional[str] = None,
+    ) -> None:
+        """
+        Delete a pipeline by its ID.
+
+        This method permanently removes a pipeline and all its configuration
+        from the Airia platform. This action cannot be undone.
+
+        Args:
+            pipeline_id (str): The unique identifier of the pipeline to delete.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+
+        Returns:
+            None: This method returns nothing upon successful deletion (204 No Content).
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The pipeline_id doesn't exist (404)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaClient
+
+            client = AiriaClient(api_key="your_api_key")
+
+            # Delete a pipeline
+            client.pipelines_config.delete_pipeline(
+                pipeline_id="your_pipeline_id"
+            )
+            print("Pipeline deleted successfully")
+            ```
+
+        Warning:
+            This operation is permanent and cannot be reversed. Ensure you have
+            the correct pipeline_id before calling this method.
+        """
+        request_data = self._pre_delete_pipeline(
+            pipeline_id=pipeline_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        self._request_handler.make_request("DELETE", request_data, return_json=False)

airia/client/sync_client.py

@@ -21,6 +21,7 @@ from .pipeline_import import PipelineImport
 from .pipelines_config import PipelinesConfig
 from .project import Project
 from .store import Store
+from .tools import Tools
 
 
 class AiriaClient(AiriaBaseClient):
@@ -74,6 +75,7 @@ class AiriaClient(AiriaBaseClient):
         self.data_vector_search = DataVectorSearch(self._request_handler)
         self.library = Library(self._request_handler)
         self.models = Models(self._request_handler)
+        self.tools = Tools(self._request_handler)
 
     @classmethod
     def with_openai_gateway(

airia/client/tools/__init__.py

@@ -0,0 +1,4 @@
+from .async_tools import AsyncTools
+from .sync_tools import Tools
+
+__all__ = ["Tools", "AsyncTools"]

airia/client/tools/async_tools.py

@@ -0,0 +1,259 @@
+from typing import Any, Dict, List, Optional, Literal
+
+from ...types._api_version import ApiVersion
+from ...types.api.tools import CreateToolResponse
+from .._request_handler import AsyncRequestHandler
+from .base_tools import BaseTools
+
+
+class AsyncTools(BaseTools):
+    def __init__(self, request_handler: AsyncRequestHandler):
+        super().__init__(request_handler)
+
+    async def create_tool(
+        self,
+        name: str,
+        description: str,
+        purpose: str,
+        api_endpoint: str,
+        method_type: str,
+        body: str,
+        tool_credentials: Dict[str, Any],
+        headers: List[Dict[str, str]] = [],
+        parameters: List[Dict[str, Any]] = [],
+        request_timeout: int = 100,
+        body_type: Literal["Json", "XFormUrlEncoded", "None"] = "Json",
+        category: Literal["Action", "Airia", "Mcp"] = "Airia",
+        tool_type: str = "Custom",
+        provider: str = "Custom",
+        route_through_acc: bool = False,
+        should_redirect: bool = True,
+        acc_group: Optional[str] = None,
+        documentation: Optional[str] = None,
+        project_id: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        tool_metadata: Optional[List[Dict[str, Any]]] = None,
+        correlation_id: Optional[str] = None,
+    ) -> CreateToolResponse:
+        """
+        Create a new tool in the Airia platform.
+
+        Args:
+            name (str): Name of the tool.
+            description (str): Brief description of what the tool does.
+                Example: "Use this tool to get the current weather in a given location."
+            api_endpoint (str): Web API endpoint where the tool sends its requests to
+                perform its task.
+            method_type (str): HTTP method type. Valid values: "Get", "Post", "Put", "Delete".
+            purpose (str): When and why to use this tool.
+                Example: "When a user asks about the weather, including current conditions,
+                forecasts, or specific weather events."
+            body_type (str): Type of the request body. Valid values: "Json", "XFormUrlEncoded", "None".
+            category (str): Category of the tool. Valid values: "Action", "Airia", "Mcp".
+            provider (str): Provider of the tool.
+            tool_type (str): Type of the tool. Valid values: "Custom", "Calculator", "MCP",
+                "LoadMemory", "StoreMemory", etc.
+            body (str): Body of the request that the tool sends to the API.
+            headers (list[dict]): List of headers required when making the API request.
+                Each header should be a dictionary with "key" and "value" fields.
+                Example: [{"key": "Content-Type", "value": "application/json"}]
+            parameters (list[dict]): Collection of parameters required by the tool
+                to execute its function.
+            request_timeout (int): Request timeout in seconds for tool execution.
+            route_through_acc (bool): Flag indicating whether the tool should route
+                through the ACC.
+            should_redirect (bool): Flag indicating whether the tool should redirect
+                with authorization header attached.
+            tool_credentials (dict): Tool credentials model.
+            acc_group (str, optional): ACC specific group name. If provided, the tool will
+                route through this ACC group.
+            documentation (str, optional): Documentation for the tool.
+            project_id (str, optional): Unique identifier of the project to which the tool
+                is associated.
+            tags (list[str], optional): List of tags for the tool.
+            tool_metadata (list[dict], optional): User provided metadata for the tool definition.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+
+        Returns:
+            CreateToolResponse: A response object containing the created tool details
+                including its ID, creation timestamp, configuration, credentials,
+                parameters, and all provided metadata.
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - Invalid parameters are provided (400)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaAsyncClient
+            import asyncio
+
+            async def main():
+                client = AiriaAsyncClient(api_key="your_api_key")
+
+                # Create a weather tool with all required parameters
+                tool = await client.tools.create_tool(
+                    name="get_weather",
+                    description="Use this tool to get the current weather in a given location.",
+                    api_endpoint="https://api.weather.com/v1/current",
+                    method_type="Get",
+                    purpose="When a user asks about the weather, including current conditions.",
+                    body_type="None",
+                    category="Action",
+                    provider="WeatherAPI",
+                    tool_type="Custom",
+                    body="",
+                    headers=[],
+                    parameters=[],
+                    request_timeout=100,
+                    route_through_acc=False,
+                    should_redirect=False,
+                    tool_credentials={}
+                )
+                print(f"Created tool: {tool.id}")
+
+                # Create an email tool with headers and optional parameters
+                tool = await client.tools.create_tool(
+                    name="send_email",
+                    description="Send an email to a recipient.",
+                    api_endpoint="https://api.email-service.com/v1/send",
+                    method_type="Post",
+                    purpose="When a user wants to send an email message.",
+                    body_type="Json",
+                    category="Action",
+                    provider="EmailService",
+                    tool_type="Custom",
+                    body='{"to": "{{recipient}}", "subject": "{{subject}}", "body": "{{message}}"}',
+                    headers=[
+                        {"key": "Content-Type", "value": "application/json"},
+                        {"key": "Authorization", "value": "Bearer {{api_key}}"}
+                    ],
+                    parameters=[
+                        {"name": "recipient", "type": "string", "required": True},
+                        {"name": "subject", "type": "string", "required": True},
+                        {"name": "message", "type": "string", "required": True}
+                    ],
+                    request_timeout=120,
+                    route_through_acc=False,
+                    should_redirect=False,
+                    tool_credentials={},
+                    documentation="This tool sends emails using the Email Service API.",
+                    tags=["email", "communication"]
+                )
+                print(f"Created email tool: {tool.id}")
+
+                await client.close()
+
+            asyncio.run(main())
+            ```
+
+        Note:
+            - Required parameters: name, description, api_endpoint, method_type, purpose,
+              body_type, category, provider, tool_type, body, headers, parameters,
+              request_timeout, route_through_acc, should_redirect, and tool_credentials.
+            - Optional parameters: acc_group, documentation, project_id, tags, and tool_metadata.
+            - The method_type must be one of: "Get", "Post", "Put", "Delete"
+            - The body_type must be one of: "Json", "XFormUrlEncoded", "None"
+            - The category must be one of: "Action", "Airia", "Mcp"
+            - The tool_type must be one of: "Custom", "Calculator", "MCP", "LoadMemory",
+              "StoreMemory", etc.
+        """
+        request_data = self._pre_create_tool(
+            name=name,
+            description=description,
+            api_endpoint=api_endpoint,
+            method_type=method_type,
+            purpose=purpose,
+            body_type=body_type,
+            category=category,
+            provider=provider,
+            tool_type=tool_type,
+            body=body,
+            headers=headers,
+            parameters=parameters,
+            request_timeout=request_timeout,
+            route_through_acc=route_through_acc,
+            should_redirect=should_redirect,
+            tool_credentials=tool_credentials,
+            acc_group=acc_group,
+            documentation=documentation,
+            project_id=project_id,
+            tags=tags,
+            tool_metadata=tool_metadata,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        resp = await self._request_handler.make_request("POST", request_data)
+
+        return CreateToolResponse(**resp)
+
+    async def delete_tool(
+        self,
+        tool_id: str,
+        correlation_id: Optional[str] = None,
+    ) -> None:
+        """
+        Delete a tool by its ID.
+
+        This method permanently removes a tool from the Airia platform.
+        This action cannot be undone.
+
+        Args:
+            tool_id (str): The unique identifier of the tool to delete.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+
+        Returns:
+            None: This method returns nothing upon successful deletion.
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The tool_id doesn't exist (404)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaAsyncClient
+            import asyncio
+
+            async def main():
+                client = AiriaAsyncClient(api_key="your_api_key")
+
+                # Delete a tool
+                await client.tools.delete_tool(tool_id="tool_123")
+                print("Tool deleted successfully")
+
+                # Handle deletion errors
+                from airia.exceptions import AiriaAPIError
+
+                try:
+                    await client.tools.delete_tool(tool_id="nonexistent_id")
+                except AiriaAPIError as e:
+                    if e.status_code == 404:
+                        print("Tool not found")
+                    else:
+                        print(f"Error deleting tool: {e.message}")
+
+                await client.close()
+
+            asyncio.run(main())
+            ```
+
+        Note:
+            This operation is permanent and cannot be undone. Make sure you have
+            the correct tool_id before calling this method.
+        """
+        request_data = self._pre_delete_tool(
+            tool_id=tool_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        await self._request_handler.make_request(
+            "DELETE", request_data, return_json=False
+        )

airia/client/tools/base_tools.py

@@ -0,0 +1,153 @@
+from typing import Any, Dict, List, Optional, Union
+from urllib.parse import urljoin
+
+from ...types._api_version import ApiVersion
+from .._request_handler import AsyncRequestHandler, RequestHandler
+
+
+class BaseTools:
+    def __init__(self, request_handler: Union[RequestHandler, AsyncRequestHandler]):
+        self._request_handler = request_handler
+
+    def _pre_create_tool(
+        self,
+        name: str,
+        description: str,
+        api_endpoint: str,
+        method_type: str,
+        purpose: str,
+        body_type: str,
+        category: str,
+        provider: str,
+        tool_type: str,
+        body: str,
+        headers: List[Dict[str, str]],
+        parameters: List[Dict[str, Any]],
+        request_timeout: int,
+        route_through_acc: bool,
+        should_redirect: bool,
+        tool_credentials: Dict[str, Any],
+        acc_group: Optional[str] = None,
+        documentation: Optional[str] = None,
+        project_id: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        tool_metadata: Optional[List[Dict[str, Any]]] = None,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        """
+        Prepare request data for creating a new tool.
+
+        This internal method constructs the URL and payload for tool creation
+        requests, including all tool configuration and metadata.
+
+        Args:
+            name: Name of the tool
+            description: Brief description of what the tool does
+            api_endpoint: Web API endpoint where the tool sends its requests
+            method_type: HTTP method type (Get, Post, Put, Delete)
+            purpose: When and why to use this tool
+            body_type: Type of the request body (Json, XFormUrlEncoded, None)
+            category: Category of the tool (Action, Airia, Mcp)
+            provider: Provider of the tool
+            tool_type: Type of the tool (Custom, Calculator, MCP, etc.)
+            body: Body of the request that the tool sends to the API
+            headers: List of headers required when making the API request
+            parameters: Collection of parameters required by the tool
+            request_timeout: Request timeout in seconds for tool execution
+            route_through_acc: Flag indicating whether the tool should route through the ACC
+            should_redirect: Flag indicating whether the tool should redirect with authorization header
+            tool_credentials: Tool credentials
+            acc_group: Optional ACC specific group name
+            documentation: Optional documentation for the tool
+            project_id: Optional unique identifier of the project to which the tool is associated
+            tags: Optional list of tags for the tool
+            tool_metadata: Optional user provided metadata for the tool definition
+            correlation_id: Optional correlation ID for tracing
+            api_version: API version to use for the request
+
+        Returns:
+            RequestData: Prepared request data for the tool creation endpoint
+
+        Raises:
+            ValueError: If an invalid API version is provided
+        """
+        if api_version not in ApiVersion.as_list():
+            raise ValueError(
+                f"Invalid API version: {api_version}. Valid versions are: {', '.join(ApiVersion.as_list())}"
+            )
+        url = urljoin(self._request_handler.base_url, f"{api_version}/Tools")
+
+        payload: Dict[str, Any] = {
+            "name": name,
+            "description": description,
+            "apiEndpoint": api_endpoint,
+            "methodType": method_type,
+            "purpose": purpose,
+            "bodyType": body_type,
+            "category": category,
+            "provider": provider,
+            "toolType": tool_type,
+            "body": body,
+            "headers": headers,
+            "parameters": parameters,
+            "requestTimeout": request_timeout,
+            "routeThroughACC": route_through_acc,
+            "shouldRedirect": should_redirect,
+            "toolCredentials": tool_credentials,
+        }
+
+        # Add optional fields only if they are provided
+        if acc_group is not None:
+            payload["accGroup"] = acc_group
+        if documentation is not None:
+            payload["documentation"] = documentation
+        if project_id is not None:
+            payload["projectId"] = project_id
+        if tags is not None:
+            payload["tags"] = tags
+        if tool_metadata is not None:
+            payload["toolMetadata"] = tool_metadata
+
+        request_data = self._request_handler.prepare_request(
+            url=url, payload=payload, correlation_id=correlation_id
+        )
+
+        return request_data
+
+    def _pre_delete_tool(
+        self,
+        tool_id: str,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        """
+        Prepare request data for deleting a tool by ID.
+
+        This internal method constructs the URL for tool deletion
+        requests using the provided tool identifier.
+
+        Args:
+            tool_id: ID of the tool to delete
+            correlation_id: Optional correlation ID for tracing
+            api_version: API version to use for the request
+
+        Returns:
+            RequestData: Prepared request data for the tool deletion endpoint
+
+        Raises:
+            ValueError: If an invalid API version is provided
+        """
+        if api_version not in ApiVersion.as_list():
+            raise ValueError(
+                f"Invalid API version: {api_version}. Valid versions are: {', '.join(ApiVersion.as_list())}"
+            )
+        url = urljoin(
+            self._request_handler.base_url,
+            f"{api_version}/Tools/{tool_id}",
+        )
+        request_data = self._request_handler.prepare_request(
+            url, correlation_id=correlation_id
+        )
+
+        return request_data

airia/client/tools/sync_tools.py

@@ -0,0 +1,245 @@
+from typing import Any, Dict, List, Optional, Literal
+
+from ...types._api_version import ApiVersion
+from ...types.api.tools import CreateToolResponse
+from .._request_handler import RequestHandler
+from .base_tools import BaseTools
+
+
+class Tools(BaseTools):
+    def __init__(self, request_handler: RequestHandler):
+        super().__init__(request_handler)
+
+    def create_tool(
+        self,
+        name: str,
+        description: str,
+        purpose: str,
+        api_endpoint: str,
+        method_type: str,
+        body: str,
+        tool_credentials: Dict[str, Any],
+        headers: List[Dict[str, str]] = [],
+        parameters: List[Dict[str, Any]] = [],
+        request_timeout: int = 100,
+        body_type: Literal["Json", "XFormUrlEncoded", "None"] = "Json",
+        category: Literal["Action", "Airia", "Mcp"] = "Airia",
+        tool_type: str = "Custom",
+        provider: str = "Custom",
+        route_through_acc: bool = False,
+        should_redirect: bool = True,
+        acc_group: Optional[str] = None,
+        documentation: Optional[str] = None,
+        project_id: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        tool_metadata: Optional[List[Dict[str, Any]]] = None,
+        correlation_id: Optional[str] = None,
+    ) -> CreateToolResponse:
+        """
+        Create a new tool in the Airia platform.
+
+        Args:
+            name (str): Name of the tool.
+            description (str): Brief description of what the tool does.
+                Example: "Use this tool to get the current weather in a given location."
+            purpose (str): When and why to use this tool.
+                Example: "When a user asks about the weather, including current conditions,
+                forecasts, or specific weather events."
+            api_endpoint (str): Web API endpoint where the tool sends its requests to
+                perform its task.
+            method_type (str): HTTP method type. Valid values: "Get", "Post", "Put", "Delete".
+            body_type (str): Type of the request body. Valid values: "Json", "XFormUrlEncoded", "None".
+            category (str): Category of the tool. Valid values: "Action", "Airia", "Mcp".
+            provider (str): Provider of the tool.
+            tool_type (str): Type of the tool. Valid values: "Custom", "Calculator", "MCP",
+                "LoadMemory", "StoreMemory", etc.
+            body (str): Body of the request that the tool sends to the API.
+            headers (list[dict]): List of headers required when making the API request.
+                Each header should be a dictionary with "key" and "value" fields.
+                Example: [{"key": "Content-Type", "value": "application/json"}]
+            parameters (list[dict]): Collection of parameters required by the tool
+                to execute its function.
+            request_timeout (int): Request timeout in seconds for tool execution.
+            route_through_acc (bool): Flag indicating whether the tool should route
+                through the ACC.
+            should_redirect (bool): Flag indicating whether the tool should redirect
+                with authorization header attached.
+            tool_credentials (dict): Tool credentials model.
+            acc_group (str, optional): ACC specific group name. If provided, the tool will
+                route through this ACC group.
+            documentation (str, optional): Documentation for the tool.
+            project_id (str, optional): Unique identifier of the project to which the tool
+                is associated.
+            tags (list[str], optional): List of tags for the tool.
+            tool_metadata (list[dict], optional): User provided metadata for the tool definition.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+
+        Returns:
+            CreateToolResponse: A response object containing the created tool details
+                including its ID, creation timestamp, configuration, credentials,
+                parameters, and all provided metadata.
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - Invalid parameters are provided (400)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaClient
+
+            client = AiriaClient(api_key="your_api_key")
+
+            # Create a weather tool with all required parameters
+            tool = client.tools.create_tool(
+                name="get_weather",
+                description="Use this tool to get the current weather in a given location.",
+                api_endpoint="https://api.weather.com/v1/current",
+                method_type="Get",
+                purpose="When a user asks about the weather, including current conditions.",
+                body_type="None",
+                category="Action",
+                provider="WeatherAPI",
+                tool_type="Custom",
+                body="",
+                headers=[],
+                parameters=[],
+                request_timeout=100,
+                route_through_acc=False,
+                should_redirect=False,
+                tool_credentials={}
+            )
+            print(f"Created tool: {tool.id}")
+
+            # Create an email tool with headers and optional parameters
+            tool = client.tools.create_tool(
+                name="send_email",
+                description="Send an email to a recipient.",
+                api_endpoint="https://api.email-service.com/v1/send",
+                method_type="Post",
+                purpose="When a user wants to send an email message.",
+                body_type="Json",
+                category="Action",
+                provider="EmailService",
+                tool_type="Custom",
+                body='{"to": "{{recipient}}", "subject": "{{subject}}", "body": "{{message}}"}',
+                headers=[
+                    {"key": "Content-Type", "value": "application/json"},
+                    {"key": "Authorization", "value": "Bearer {{api_key}}"}
+                ],
+                parameters=[
+                    {"name": "recipient", "type": "string", "required": True},
+                    {"name": "subject", "type": "string", "required": True},
+                    {"name": "message", "type": "string", "required": True}
+                ],
+                request_timeout=120,
+                route_through_acc=False,
+                should_redirect=False,
+                tool_credentials={},
+                documentation="This tool sends emails using the Email Service API.",
+                tags=["email", "communication"]
+            )
+            print(f"Created email tool: {tool.id}")
+            ```
+
+        Note:
+            - Required parameters: name, description, api_endpoint, method_type, purpose,
+              body_type, category, provider, tool_type, body, headers, parameters,
+              request_timeout, route_through_acc, should_redirect, and tool_credentials.
+            - Optional parameters: acc_group, documentation, project_id, tags, and tool_metadata.
+            - The method_type must be one of: "Get", "Post", "Put", "Delete"
+            - The body_type must be one of: "Json", "XFormUrlEncoded", "None"
+            - The category must be one of: "Action", "Airia", "Mcp"
+            - The tool_type must be one of: "Custom", "Calculator", "MCP", "LoadMemory",
+              "StoreMemory", etc.
+        """
+        request_data = self._pre_create_tool(
+            name=name,
+            description=description,
+            api_endpoint=api_endpoint,
+            method_type=method_type,
+            purpose=purpose,
+            body_type=body_type,
+            category=category,
+            provider=provider,
+            tool_type=tool_type,
+            body=body,
+            headers=headers,
+            parameters=parameters,
+            request_timeout=request_timeout,
+            route_through_acc=route_through_acc,
+            should_redirect=should_redirect,
+            tool_credentials=tool_credentials,
+            acc_group=acc_group,
+            documentation=documentation,
+            project_id=project_id,
+            tags=tags,
+            tool_metadata=tool_metadata,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        resp = self._request_handler.make_request("POST", request_data)
+
+        return CreateToolResponse(**resp)
+
+    def delete_tool(
+        self,
+        tool_id: str,
+        correlation_id: Optional[str] = None,
+    ) -> None:
+        """
+        Delete a tool by its ID.
+
+        This method permanently removes a tool from the Airia platform.
+        This action cannot be undone.
+
+        Args:
+            tool_id (str): The unique identifier of the tool to delete.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+
+        Returns:
+            None: This method returns nothing upon successful deletion.
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The tool_id doesn't exist (404)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaClient
+
+            client = AiriaClient(api_key="your_api_key")
+
+            # Delete a tool
+            client.tools.delete_tool(tool_id="tool_123")
+            print("Tool deleted successfully")
+
+            # Handle deletion errors
+            from airia.exceptions import AiriaAPIError
+
+            try:
+                client.tools.delete_tool(tool_id="nonexistent_id")
+            except AiriaAPIError as e:
+                if e.status_code == 404:
+                    print("Tool not found")
+                else:
+                    print(f"Error deleting tool: {e.message}")
+            ```
+
+        Note:
+            This operation is permanent and cannot be undone. Make sure you have
+            the correct tool_id before calling this method.
+        """
+        request_data = self._pre_delete_tool(
+            tool_id=tool_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        self._request_handler.make_request("DELETE", request_data, return_json=False)

airia/types/api/__init__.py

@@ -1,3 +1,4 @@
 from . import attachments as attachments
 from . import models as models
 from . import pipeline_import as pipeline_import
+from . import tools as tools

airia/types/api/tools/__init__.py

@@ -0,0 +1,7 @@
+from ._tools import CreateToolResponse, ToolHeader, ToolParameter
+
+__all__ = [
+    "CreateToolResponse",
+    "ToolHeader",
+    "ToolParameter",
+]

airia/types/api/tools/_tools.py

@@ -0,0 +1,223 @@
+"""
+Pydantic models for tool management API responses.
+
+This module defines data structures for tool operations including
+creation and configuration within the Airia platform.
+"""
+
+from typing import Optional, List
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+
+class ToolHeader(BaseModel):
+    """Key-value pair header for a tool definition.
+
+    Attributes:
+        key: The key of the header
+        value: The value of the header
+    """
+
+    key: str
+    value: str
+
+
+class ToolParameter(BaseModel):
+    """Parameter definition for a tool.
+
+    Attributes:
+        name: Name of the parameter
+        type: Type of the parameter
+        description: Description of what the parameter does
+        default: Default value for the parameter
+        valid_options: List of valid options for the parameter
+        array_item_type: Type of items if this parameter is an array
+        parameters: Nested parameters for complex types
+        requirement: Whether the parameter is required or optional
+    """
+
+    name: str
+    type: str
+    description: str
+    default: Optional[str] = None
+    valid_options: Optional[List[str]] = Field(None, alias="validOptions")
+    array_item_type: Optional[str] = Field(None, alias="arrayItemType")
+    parameters: Optional[List["ToolParameter"]] = None
+    requirement: str
+
+
+class ToolCredentialSettings(BaseModel):
+    """Settings for tool credentials.
+
+    Attributes:
+        available_credential_types: List of available credential types
+        default_value: Default credential value
+        platform_supported_oauth_types: List of OAuth types supported by the platform
+    """
+
+    available_credential_types: List[str] = Field(alias="availableCredentialTypes")
+    default_value: Optional[str] = Field(None, alias="defaultValue")
+    platform_supported_oauth_types: List[str] = Field(
+        alias="platformSupportedOAuthTypes"
+    )
+
+
+class ToolCredential(BaseModel):
+    """Tool credential information.
+
+    Attributes:
+        id: Unique identifier for the credential
+        name: Name of the credential
+        display_identifier_name: Display name for the credential identifier
+        created_at: When the credential was created
+        project_id: ID of the project this credential belongs to
+        type: Type of credential
+        expired: Whether the credential has expired
+        expires_on: When the credential expires
+        administrative_scope: Scope of the credential (e.g., "Tenant")
+        user_id: ID of the user who owns the credential
+    """
+
+    id: str
+    name: Optional[str] = None
+    display_identifier_name: Optional[str] = Field(None, alias="displayIdentifierName")
+    created_at: Optional[datetime] = Field(None, alias="createdAt")
+    project_id: Optional[str] = Field(None, alias="projectId")
+    type: str
+    expired: Optional[bool] = None
+    expires_on: Optional[datetime] = Field(None, alias="expiresOn")
+    administrative_scope: str = Field(alias="administrativeScope")
+    user_id: Optional[str] = Field(None, alias="userId")
+
+
+class ToolCredentials(BaseModel):
+    """Credentials configuration for a tool.
+
+    Attributes:
+        tool_credential_settings: Settings for tool credentials
+        tool_credentials: The actual credential object
+        tool_credentials_id: ID of the tool credentials
+        auth_required: Whether authentication is required
+        use_user_credentials: Whether to use user credentials
+        user_credential_connector_id: ID of the user credential connector
+        use_user_credentials_type: Type of user credentials to use
+        credentials_source_type: Source type of the credentials
+        use_airia_key_support: Whether Airia key support is enabled
+    """
+
+    tool_credential_settings: ToolCredentialSettings = Field(
+        alias="toolCredentialSettings"
+    )
+    tool_credentials: Optional[ToolCredential] = Field(None, alias="toolCredentials")
+    tool_credentials_id: Optional[str] = Field(None, alias="toolCredentialsId")
+    auth_required: bool = Field(alias="authRequired")
+    use_user_credentials: bool = Field(alias="useUserCredentials")
+    user_credential_connector_id: Optional[str] = Field(
+        None, alias="userCredentialConnectorId"
+    )
+    use_user_credentials_type: str = Field(alias="useUserCredentialsType")
+    credentials_source_type: str = Field(alias="credentialsSourceType")
+    use_airia_key_support: bool = Field(alias="useAiriaKeySupport")
+
+
+class ProjectReference(BaseModel):
+    """Reference to a project.
+
+    Attributes:
+        id: Project ID
+        name: Project name
+    """
+
+    id: str
+    name: str
+
+
+class ToolMetadata(BaseModel):
+    """Metadata key-value pair for a tool.
+
+    Attributes:
+        key: The metadata key
+        value: The metadata value
+    """
+
+    key: str
+    value: str
+
+
+class CreateToolResponse(BaseModel):
+    """Response data for tool creation and retrieval operations.
+
+    This response contains complete information about a tool including
+    its configuration, credentials, parameters, and metadata.
+
+    Attributes:
+        id: Unique identifier for the tool
+        created_at: Timestamp when the tool was created
+        updated_at: Timestamp when the tool was last updated
+        tool_type: Type of the tool (e.g., "custom")
+        name: Name of the tool
+        standardized_name: Standardized version of the tool name
+        display_name: Display name of the tool (includes provider suffix for gateway tools)
+        origin: Origin of the tool
+        description: Brief description of what the tool does
+        method_type: HTTP method type (Get, Post, Put, Delete)
+        purpose: When and why to use this tool
+        api_endpoint: Web API endpoint where the tool sends requests
+        provider: Provider of the tool
+        tool_credentials: Credentials configuration for the tool
+        headers: Headers required when making API requests
+        body: Body of the request that the tool sends to the API
+        body_type: Type of the request body (Json, XFormUrlEncoded, None)
+        parameters: List of parameters the tool accepts
+        project_id: ID of the project this tool belongs to
+        project_name: Name of the project this tool belongs to
+        project: Project reference object
+        children: Child tool definitions
+        route_through_acc: Whether the tool should route through an ACC specific group
+        should_redirect: Whether the tool should redirect
+        acc_group: ACC specific group name
+        documentation: Documentation for the tool
+        tags: List of tags associated with the tool
+        tool_metadata: List of metadata key-value pairs
+        supports_pagination: Whether the tool supports pagination
+        category: Category of the tool (Action, Airia, Mcp)
+        request_timeout: Request timeout in seconds
+    """
+
+    id: str
+    created_at: datetime = Field(alias="createdAt")
+    updated_at: datetime = Field(alias="updatedAt")
+    tool_type: str = Field(alias="toolType")
+    name: str
+    standardized_name: str = Field(alias="standardizedName")
+    display_name: Optional[str] = Field(None, alias="displayName")
+    origin: Optional[str] = None
+    description: str
+    method_type: str = Field(alias="methodType")
+    purpose: str
+    api_endpoint: str = Field(alias="apiEndpoint")
+    provider: str
+    tool_credentials: ToolCredentials = Field(alias="toolCredentials")
+    headers: List[ToolHeader]
+    body: str
+    body_type: str = Field(alias="bodyType")
+    parameters: List[ToolParameter]
+    project_id: Optional[str] = Field(None, alias="projectId")
+    project_name: Optional[str] = Field(None, alias="projectName")
+    project: Optional[ProjectReference] = None
+    children: Optional[List["CreateToolResponse"]] = None
+    route_through_acc: bool = Field(alias="routeThroughACC")
+    should_redirect: bool = Field(alias="shouldRedirect")
+    acc_group: Optional[str] = Field(None, alias="accGroup")
+    documentation: Optional[str] = None
+    tags: Optional[List[str]] = None
+    tool_metadata: Optional[List[ToolMetadata]] = Field(None, alias="toolMetadata")
+    supports_pagination: Optional[bool] = Field(None, alias="supportsPagination")
+    category: str
+    request_timeout: int = Field(alias="requestTimeout")
+
+
+# Update forward references
+ToolParameter.model_rebuild()
+CreateToolResponse.model_rebuild()

{airia-0.1.26.dist-info → airia-0.1.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airia
-Version: 0.1.26
+Version: 0.1.27
 Summary: Python SDK for Airia API
 Author-email: Airia LLC <support@airia.com>
 License: MIT

{airia-0.1.26.dist-info → airia-0.1.27.dist-info}/RECORD

@@ -3,9 +3,9 @@ airia/constants.py,sha256=oKABowOTsJPIQ1AgtVpNN73oKuhh1DekBC5axYSm8lY,647
 airia/exceptions.py,sha256=l1FCKlWC6tONvAxSxv4YEAXjpHEM-eQQQ3mEtSkJvhc,1233
 airia/logs.py,sha256=oHU8ByekHu-udBB-5abY39wUct_26t8io-A1Kcl7D3U,4538
 airia/client/__init__.py,sha256=6gSQ9bl7j79q1HPE0o5py3IRdkwWWuU_7J4h05Dd2o8,127
-airia/client/async_client.py,sha256=1jWgAF2LPaFDWDJI2Yn8t-ApmbnZUvU1xR2z2VBqJmg,7448
+airia/client/async_client.py,sha256=ueHaYuPgcdm8dI0m_6LIl7oMT4lZREqa0i8-WFPtsJw,7533
 airia/client/base_client.py,sha256=ftyLi2E3Hb4CQFYfiknitJA0sWDTylCiUbde0qkWYhg,3182
-airia/client/sync_client.py,sha256=Y29uwPJ-yxpkpYK6PmbmTQh4bf9OCJynpZ8LGmpwOag,7267
+airia/client/sync_client.py,sha256=qJoSfSQH_4kSTLRQPjEtYAeLHkLVk78bkI-Hnr8rNiU,7342
 airia/client/_request_handler/__init__.py,sha256=FOdJMfzjN0Tw0TeD8mDJwHgte70Fw_j08EljtfulCvw,157
 airia/client/_request_handler/async_request_handler.py,sha256=yvPaGDTb6GZwU5V9-AuLv-z0XJ-NhOg974VKzD46vl4,11556
 airia/client/_request_handler/base_request_handler.py,sha256=dObRK6e_V_cGslHzC3WrNQ5lZqmMamjxNhVpb7P1L_w,3516
@@ -43,9 +43,9 @@ airia/client/pipeline_import/async_pipeline_import.py,sha256=BC6HkkMNiU7_7H8vAhX
 airia/client/pipeline_import/base_pipeline_import.py,sha256=_6AHf_bL3RABDaIQN3-ivL3Z8NR1l0J7A4S0ilJCluY,3844
 airia/client/pipeline_import/sync_pipeline_import.py,sha256=SaF8uIWGFhk5i0e45JGY2WXLVNyJPq4WXwUA78m7Yv8,7000
 airia/client/pipelines_config/__init__.py,sha256=Mjn3ie-bQo6zjayxrJDvoJG2vKis72yGt_CQkvtREw4,163
-airia/client/pipelines_config/async_pipelines_config.py,sha256=H3W5yCUWsd93cq1i-PdQXyq6MG_dW0Jq7pjU2ZfqNf0,7611
-airia/client/pipelines_config/base_pipelines_config.py,sha256=UotK6-SB19fUSlUEHM_aNQTWD4GLlRUynF-Gs0Nvu0c,3917
-airia/client/pipelines_config/sync_pipelines_config.py,sha256=bSO7BFC7Bk18tlvjLaWD74ULWFu6uCln4Ml5TbUMrBg,7506
+airia/client/pipelines_config/async_pipelines_config.py,sha256=EP5qrNyrXDyHa_xjkQDqAoc9_aAnyQ9fwS-9byhLdYs,9398
+airia/client/pipelines_config/base_pipelines_config.py,sha256=VjMBmHn8N11ZK5Kvqfc72nWIgfQcAxy5MOu7_iloVjU,5163
+airia/client/pipelines_config/sync_pipelines_config.py,sha256=TNZk2tCLT_UbbkbVImySESO7foXwohzcxFo72Wohgb8,9265
 airia/client/project/__init__.py,sha256=GGEGfxtNzSO_BMAJ8Wfo8ZTq8BIdR6MHf6gSwhPv9mE,113
 airia/client/project/async_project.py,sha256=OrIiqopKSXAhkYJi6yjoR-YYVUxzll1ldDJkJW1rIBM,4534
 airia/client/project/base_project.py,sha256=4vP_dKGAt17mdzp3eW3ER8E0C0XMQ9P7JAEH2EH0imE,2432
@@ -54,10 +54,14 @@ airia/client/store/__init__.py,sha256=-rbtYQ8PTaFA6Fs2dm7Db2C3RDNvagaK3iE4PpLRcj
 airia/client/store/async_store.py,sha256=wlYbK2AlTuJCrk3otdpO68W208166xyKpZymtuA5PyA,13557
 airia/client/store/base_store.py,sha256=RUIGkKb2KiKZfzmDJIiPrLSes_VAnJA4xouIqxkEazI,8106
 airia/client/store/sync_store.py,sha256=DNBhTckdoVnTqTVwFp_J42l-XkSHX3sCKVR7J4b79RU,12578
+airia/client/tools/__init__.py,sha256=9bRyvbHD_AthBZA8YXMG79ZYoQjoGCl6mVnu5kVH1Jo,101
+airia/client/tools/async_tools.py,sha256=Qnh0aDT-QM0P_Au3G-ehBL4iSxbMMf58TsbBBqzF1ow,11231
+airia/client/tools/base_tools.py,sha256=YFTLESJBwvm5Z4YiRiadOQis9PH8Cwz6QC4scf1hazw,5913
+airia/client/tools/sync_tools.py,sha256=mFWkHwbcHPf95UB58TDtAgbBvDbpXylEC1S5fRXFhAE,10618
 airia/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 airia/types/_api_version.py,sha256=Uzom6O2ZG92HN_Z2h-lTydmO2XYX9RVs4Yi4DJmXytE,255
 airia/types/_request_data.py,sha256=q8t7KfO2WvgbPVYPvPWiwYb8LyP0kovlOgHFhZIU6ns,1278
-airia/types/api/__init__.py,sha256=gXayaXdsdHABeaH9501uO7A6146j7cVteUz_z61WnAo,121
+airia/types/api/__init__.py,sha256=hAkcgB07FFdYUqGAP9-7CUFTBTYUOn6DFRH4wMo2PoM,150
 airia/types/api/attachments/__init__.py,sha256=zFSCwsmPr05I7NJRG6MCWME3AKhBpL0MhgOBOaF7rok,78
 airia/types/api/attachments/upload_file.py,sha256=XBCm1lZJAloFxmyp_3fbtuJ9Y28O-mbAfwy6D0EvTgQ,457
 airia/types/api/conversations/__init__.py,sha256=W6GlNVZCAY5eViJOoPl1bY9_etRBWeUnYZJJt7WHtfI,269
@@ -84,11 +88,13 @@ airia/types/api/project/get_projects.py,sha256=Ot8mq6VnXrGXZs7FQ0UuRYSyuCeER7YeC
 airia/types/api/store/__init__.py,sha256=BgViwV_SHE9cxtilPnA2xWRk6MkAbxYxansmGeZR3nw,341
 airia/types/api/store/get_file.py,sha256=Li3CpWUktQruNeoKSTlHJPXzNMaysG_Zy-fXGji8zs8,6174
 airia/types/api/store/get_files.py,sha256=v22zmOuTSFqzrS73L5JL_FgBeF5a5wutv1nK4IHAoW0,700
+airia/types/api/tools/__init__.py,sha256=r4jcHknQcLIb3jVkGR5lcmuapHqln7-rot3EBCNmZtI,146
+airia/types/api/tools/_tools.py,sha256=M8nVRqhTpdbIzPs2z4Pi11BFtOnbgtNk3_RnDyViM_M,8348
 airia/types/sse/__init__.py,sha256=KWnNTfsQnthfrU128pUX6ounvSS7DvjC-Y21FE-OdMk,1863
 airia/types/sse/sse_messages.py,sha256=asq9KG5plT2XSgQMz-Nqo0WcKlXvE8UT3E-WLhCegPk,30244
 airia/utils/sse_parser.py,sha256=XCTkuaroYWaVQOgBq8VpbseQYSAVruF69AvKUwZQKTA,4251
-airia-0.1.26.dist-info/licenses/LICENSE,sha256=R3ClUMMKPRItIcZ0svzyj2taZZnFYw568YDNzN9KQ1Q,1066
-airia-0.1.26.dist-info/METADATA,sha256=jBegGTV52UEAp9zWWlbp8tklZc0sAUAgleVKkQOfEjY,4506
-airia-0.1.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-airia-0.1.26.dist-info/top_level.txt,sha256=qUQEKfs_hdOYTwjKj1JZbRhS5YeXDNaKQaVTrzabS6w,6
-airia-0.1.26.dist-info/RECORD,,
+airia-0.1.27.dist-info/licenses/LICENSE,sha256=R3ClUMMKPRItIcZ0svzyj2taZZnFYw568YDNzN9KQ1Q,1066
+airia-0.1.27.dist-info/METADATA,sha256=F_fbsYlh5Av4u2zFd10Yx3CFTYYeplBWx2tIZK9cdU8,4506
+airia-0.1.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+airia-0.1.27.dist-info/top_level.txt,sha256=qUQEKfs_hdOYTwjKj1JZbRhS5YeXDNaKQaVTrzabS6w,6
+airia-0.1.27.dist-info/RECORD,,