intentkit 0.6.0.dev13__py3-none-any.whl → 0.6.0.dev14__py3-none-any.whl

intentkit/skills/supabase/base.py

@@ -0,0 +1,72 @@
+from typing import Type
+
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill, SkillContext
+
+
+class SupabaseBaseTool(IntentKitSkill):
+    """Base class for Supabase tools."""
+
+    name: str = Field(description="The name of the tool")
+    description: str = Field(description="A description of what the tool does")
+    args_schema: Type[BaseModel]
+    skill_store: SkillStoreABC = Field(
+        description="The skill store for persisting data"
+    )
+
+    @property
+    def category(self) -> str:
+        return "supabase"
+
+    def get_supabase_config(self, config: dict) -> tuple[str, str]:
+        """Get Supabase URL and key from config.
+
+        Args:
+            config: The agent configuration
+
+        Returns:
+            Tuple of (supabase_url, supabase_key)
+
+        Raises:
+            ValueError: If required config is missing
+        """
+        supabase_url = config.get("supabase_url")
+        supabase_key = config.get("supabase_key")
+
+        if not supabase_url:
+            raise ValueError("supabase_url is required in config")
+        if not supabase_key:
+            raise ValueError("supabase_key is required in config")
+
+        return supabase_url, supabase_key
+
+    def validate_table_access(self, table: str, context: SkillContext) -> None:
+        """Validate if the table can be accessed for write operations in public mode.
+
+        Args:
+            table: The table name to validate
+            context: The skill context containing configuration and mode info
+
+        Raises:
+            ToolException: If table access is not allowed in public mode
+        """
+        # If in private mode (owner mode), no restrictions apply
+        if context.is_private:
+            return
+
+        # In public mode, check if table is in allowed list
+        public_write_tables = context.config.get("public_write_tables", "")
+        if not public_write_tables:
+            return
+
+        allowed_tables = [
+            t.strip() for t in public_write_tables.split(",") if t.strip()
+        ]
+        if table not in allowed_tables:
+            raise ToolException(
+                f"Table '{table}' is not allowed for public write operations. "
+                f"Allowed tables: {', '.join(allowed_tables)}"
+            )

intentkit/skills/supabase/delete_data.py

@@ -0,0 +1,102 @@
+import logging
+from typing import Any, Dict, Type
+
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+from supabase import Client, create_client
+
+from intentkit.skills.supabase.base import SupabaseBaseTool
+
+NAME = "supabase_delete_data"
+PROMPT = "Delete data from a Supabase table based on filtering conditions."
+
+logger = logging.getLogger(__name__)
+
+
+class SupabaseDeleteDataInput(BaseModel):
+    """Input for SupabaseDeleteData tool."""
+
+    table: str = Field(description="The name of the table to delete data from")
+    filters: Dict[str, Any] = Field(
+        description="Dictionary of filters to identify which records to delete (e.g., {'id': 123})"
+    )
+    returning: str = Field(
+        default="*",
+        description="Columns to return from deleted records (default: '*' for all)",
+    )
+
+
+class SupabaseDeleteData(SupabaseBaseTool):
+    """Tool for deleting data from Supabase tables.
+
+    This tool allows deleting records from Supabase tables based on filter conditions.
+    """
+
+    name: str = NAME
+    description: str = PROMPT
+    args_schema: Type[BaseModel] = SupabaseDeleteDataInput
+
+    async def _arun(
+        self,
+        table: str,
+        filters: Dict[str, Any],
+        returning: str = "*",
+        config: RunnableConfig = None,
+        **kwargs,
+    ):
+        try:
+            context = self.context_from_config(config)
+
+            # Validate table access for public mode
+            self.validate_table_access(table, context)
+
+            supabase_url, supabase_key = self.get_supabase_config(context.config)
+
+            # Create Supabase client
+            supabase: Client = create_client(supabase_url, supabase_key)
+
+            # Start building the delete query
+            query = supabase.table(table).delete()
+
+            # Apply filters to identify which records to delete
+            for column, value in filters.items():
+                if isinstance(value, dict):
+                    # Handle complex filters like {'gte': 18}
+                    for operator, filter_value in value.items():
+                        if operator == "eq":
+                            query = query.eq(column, filter_value)
+                        elif operator == "neq":
+                            query = query.neq(column, filter_value)
+                        elif operator == "gt":
+                            query = query.gt(column, filter_value)
+                        elif operator == "gte":
+                            query = query.gte(column, filter_value)
+                        elif operator == "lt":
+                            query = query.lt(column, filter_value)
+                        elif operator == "lte":
+                            query = query.lte(column, filter_value)
+                        elif operator == "like":
+                            query = query.like(column, filter_value)
+                        elif operator == "ilike":
+                            query = query.ilike(column, filter_value)
+                        elif operator == "in":
+                            query = query.in_(column, filter_value)
+                        else:
+                            logger.warning(f"Unknown filter operator: {operator}")
+                else:
+                    # Simple equality filter
+                    query = query.eq(column, value)
+
+            # Execute the delete
+            response = query.execute()
+
+            return {
+                "success": True,
+                "data": response.data,
+                "count": len(response.data) if response.data else 0,
+            }
+
+        except Exception as e:
+            logger.error(f"Error deleting data from Supabase: {str(e)}")
+            raise ToolException(f"Failed to delete data from table '{table}': {str(e)}")

intentkit/skills/supabase/fetch_data.py

@@ -0,0 +1,120 @@
+import logging
+from typing import Any, Dict, Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+from supabase import Client, create_client
+
+from intentkit.skills.supabase.base import SupabaseBaseTool
+
+NAME = "supabase_fetch_data"
+PROMPT = "Fetch data from a Supabase table with optional filtering, ordering, and pagination."
+
+logger = logging.getLogger(__name__)
+
+
+class SupabaseFetchDataInput(BaseModel):
+    """Input for SupabaseFetchData tool."""
+
+    table: str = Field(description="The name of the table to fetch data from")
+    columns: Optional[str] = Field(
+        default="*",
+        description="Comma-separated list of columns to select (default: '*' for all)",
+    )
+    filters: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Dictionary of filters to apply (e.g., {'column': 'value', 'age': {'gte': 18}})",
+    )
+    order_by: Optional[str] = Field(default=None, description="Column to order by")
+    ascending: bool = Field(
+        default=True, description="Whether to order in ascending order (default: True)"
+    )
+    limit: Optional[int] = Field(
+        default=None, description="Maximum number of records to return"
+    )
+    offset: Optional[int] = Field(
+        default=None, description="Number of records to skip for pagination"
+    )
+
+
+class SupabaseFetchData(SupabaseBaseTool):
+    """Tool for fetching data from Supabase tables.
+
+    This tool allows querying Supabase tables with filtering, ordering, and pagination.
+    """
+
+    name: str = NAME
+    description: str = PROMPT
+    args_schema: Type[BaseModel] = SupabaseFetchDataInput
+
+    async def _arun(
+        self,
+        table: str,
+        columns: Optional[str] = "*",
+        filters: Optional[Dict[str, Any]] = None,
+        order_by: Optional[str] = None,
+        ascending: bool = True,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        config: RunnableConfig = None,
+        **kwargs,
+    ):
+        try:
+            context = self.context_from_config(config)
+            supabase_url, supabase_key = self.get_supabase_config(context.config)
+
+            # Create Supabase client
+            supabase: Client = create_client(supabase_url, supabase_key)
+
+            # Start building the query
+            query = supabase.table(table).select(columns)
+
+            # Apply filters if provided
+            if filters:
+                for column, value in filters.items():
+                    if isinstance(value, dict):
+                        # Handle complex filters like {'gte': 18}
+                        for operator, filter_value in value.items():
+                            if operator == "eq":
+                                query = query.eq(column, filter_value)
+                            elif operator == "neq":
+                                query = query.neq(column, filter_value)
+                            elif operator == "gt":
+                                query = query.gt(column, filter_value)
+                            elif operator == "gte":
+                                query = query.gte(column, filter_value)
+                            elif operator == "lt":
+                                query = query.lt(column, filter_value)
+                            elif operator == "lte":
+                                query = query.lte(column, filter_value)
+                            elif operator == "like":
+                                query = query.like(column, filter_value)
+                            elif operator == "ilike":
+                                query = query.ilike(column, filter_value)
+                            elif operator == "in":
+                                query = query.in_(column, filter_value)
+                            else:
+                                logger.warning(f"Unknown filter operator: {operator}")
+                    else:
+                        # Simple equality filter
+                        query = query.eq(column, value)
+
+            # Apply ordering if provided
+            if order_by:
+                query = query.order(order_by, desc=not ascending)
+
+            # Apply pagination
+            if limit:
+                query = query.limit(limit)
+            if offset:
+                query = query.offset(offset)
+
+            # Execute the query
+            response = query.execute()
+
+            return {"success": True, "data": response.data, "count": len(response.data)}
+
+        except Exception as e:
+            logger.error(f"Error fetching data from Supabase: {str(e)}")
+            raise ToolException(f"Failed to fetch data from table '{table}': {str(e)}")

intentkit/skills/supabase/insert_data.py

@@ -0,0 +1,70 @@
+import logging
+from typing import Any, Dict, List, Type, Union
+
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+from supabase import Client, create_client
+
+from intentkit.skills.supabase.base import SupabaseBaseTool
+
+NAME = "supabase_insert_data"
+PROMPT = "Insert new data into a Supabase table."
+
+logger = logging.getLogger(__name__)
+
+
+class SupabaseInsertDataInput(BaseModel):
+    """Input for SupabaseInsertData tool."""
+
+    table: str = Field(description="The name of the table to insert data into")
+    data: Union[Dict[str, Any], List[Dict[str, Any]]] = Field(
+        description="The data to insert. Can be a single object or a list of objects"
+    )
+    returning: str = Field(
+        default="*",
+        description="Columns to return after insertion (default: '*' for all)",
+    )
+
+
+class SupabaseInsertData(SupabaseBaseTool):
+    """Tool for inserting data into Supabase tables.
+
+    This tool allows inserting single or multiple records into Supabase tables.
+    """
+
+    name: str = NAME
+    description: str = PROMPT
+    args_schema: Type[BaseModel] = SupabaseInsertDataInput
+
+    async def _arun(
+        self,
+        table: str,
+        data: Union[Dict[str, Any], List[Dict[str, Any]]],
+        returning: str = "*",
+        config: RunnableConfig = None,
+        **kwargs,
+    ):
+        try:
+            context = self.context_from_config(config)
+
+            # Validate table access for public mode
+            self.validate_table_access(table, context)
+
+            supabase_url, supabase_key = self.get_supabase_config(context.config)
+
+            # Create Supabase client
+            supabase: Client = create_client(supabase_url, supabase_key)
+
+            # Insert data
+            response = supabase.table(table).insert(data).execute()
+
+            return {
+                "success": True,
+                "data": response.data,
+                "count": len(response.data) if response.data else 0,
+            }
+
+        except Exception as e:
+            logger.error(f"Error inserting data into Supabase: {str(e)}")
+            raise ToolException(f"Failed to insert data into table '{table}': {str(e)}")

intentkit/skills/supabase/invoke_function.py

@@ -0,0 +1,74 @@
+import logging
+from typing import Any, Dict, Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+from supabase import Client, create_client
+
+from intentkit.skills.supabase.base import SupabaseBaseTool
+
+NAME = "supabase_invoke_function"
+PROMPT = "Invoke a Supabase Edge Function with optional parameters."
+
+logger = logging.getLogger(__name__)
+
+
+class SupabaseInvokeFunctionInput(BaseModel):
+    """Input for SupabaseInvokeFunction tool."""
+
+    function_name: str = Field(description="The name of the Edge Function to invoke")
+    parameters: Optional[Dict[str, Any]] = Field(
+        default=None, description="Optional parameters to pass to the function"
+    )
+    headers: Optional[Dict[str, str]] = Field(
+        default=None, description="Optional headers to include in the request"
+    )
+
+
+class SupabaseInvokeFunction(SupabaseBaseTool):
+    """Tool for invoking Supabase Edge Functions.
+
+    This tool allows calling Supabase Edge Functions with optional parameters and headers.
+    """
+
+    name: str = NAME
+    description: str = PROMPT
+    args_schema: Type[BaseModel] = SupabaseInvokeFunctionInput
+
+    async def _arun(
+        self,
+        function_name: str,
+        parameters: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        config: RunnableConfig = None,
+        **kwargs,
+    ):
+        try:
+            context = self.context_from_config(config)
+            supabase_url, supabase_key = self.get_supabase_config(context.config)
+
+            # Create Supabase client
+            supabase: Client = create_client(supabase_url, supabase_key)
+
+            # Prepare function invocation parameters
+            invoke_options = {}
+            if parameters:
+                invoke_options["json"] = parameters
+            if headers:
+                invoke_options["headers"] = headers
+
+            # Invoke the Edge Function
+            response = supabase.functions.invoke(function_name, invoke_options)
+
+            return {
+                "success": True,
+                "data": response.json() if hasattr(response, "json") else response,
+                "status_code": getattr(response, "status_code", None),
+            }
+
+        except Exception as e:
+            logger.error(f"Error invoking Supabase Edge Function: {str(e)}")
+            raise ToolException(
+                f"Failed to invoke Edge Function '{function_name}': {str(e)}"
+            )

intentkit/skills/supabase/schema.json

@@ -0,0 +1,168 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "Supabase",
+  "description": "Integration with Supabase backend-as-a-service platform enabling database operations and Edge Function invocations",
+  "x-icon": "https://ai.service.crestal.dev/skills/supabase/supabase.png",
+  "x-tags": [
+    "Database",
+    "Backend"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": false
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "fetch_data": {
+          "type": "string",
+          "title": "Fetch Data",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Fetch data from Supabase tables with filtering, ordering, and pagination support",
+          "default": "disabled"
+        },
+        "insert_data": {
+          "type": "string",
+          "title": "Insert Data",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Insert new records into Supabase tables",
+          "default": "disabled"
+        },
+        "update_data": {
+          "type": "string",
+          "title": "Update Data",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Update existing records in Supabase tables based on filter conditions",
+          "default": "disabled"
+        },
+        "upsert_data": {
+          "type": "string",
+          "title": "Upsert Data",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Insert or update records in Supabase tables based on conflict resolution",
+          "default": "disabled"
+        },
+        "delete_data": {
+          "type": "string",
+          "title": "Delete Data",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Delete records from Supabase tables based on filter conditions",
+          "default": "disabled"
+        },
+        "invoke_function": {
+          "type": "string",
+          "title": "Invoke Edge Function",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Invoke Supabase Edge Functions with optional parameters and headers",
+          "default": "disabled"
+        }
+      },
+      "description": "States for each Supabase skill"
+    },
+    "api_key_provider": {
+      "type": "string",
+      "title": "API Key Provider",
+      "description": "Who provides the API key",
+      "enum": [
+        "agent_owner"
+      ],
+      "x-enum-title": [
+        "Owner Provided"
+      ],
+      "default": "agent_owner"
+    },
+    "supabase_url": {
+      "type": "string",
+      "title": "Supabase URL",
+      "description": "Your Supabase project URL (e.g., https://your-project.supabase.co)",
+      "format": "uri"
+    },
+    "supabase_key": {
+      "type": "string",
+      "title": "Supabase Anon Key",
+      "description": "Your Supabase project's anon/public key",
+      "format": "password"
+    },
+    "public_write_tables": {
+      "type": "string",
+      "title": "Public Write Tables",
+      "description": "Add tables split by comma, when insert,update,upsert,delete enabled in public use, they can only use tables from this list. When skills in owner mode, this list will not limit skills.",
+      "default": ""
+    }
+  },
+  "required": [
+    "states",
+    "enabled"
+  ],
+  "if": {
+    "properties": {
+      "enabled": {
+        "const": true
+      }
+    }
+  },
+  "then": {
+    "required": [
+      "supabase_url",
+      "supabase_key"
+    ]
+  }
+}

intentkit/skills/supabase/supabase.svg

@@ -0,0 +1,15 @@
+<svg width="109" height="113" viewBox="0 0 109 113" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M63.7076 110.284C60.8481 113.885 55.0502 111.912 54.9813 107.314L53.9738 40.0627L99.1935 40.0627C107.384 40.0627 111.952 49.5228 106.859 55.9374L63.7076 110.284Z" fill="url(#paint0_linear)"/>
+<path d="M63.7076 110.284C60.8481 113.885 55.0502 111.912 54.9813 107.314L53.9738 40.0627L99.1935 40.0627C107.384 40.0627 111.952 49.5228 106.859 55.9374L63.7076 110.284Z" fill="url(#paint1_linear)" fill-opacity="0.2"/>
+<path d="M45.317 2.07103C48.1765 -1.53037 53.9745 0.442937 54.0434 5.041L54.4849 72.2922H9.83113C1.64038 72.2922 -2.92775 62.8321 2.1655 56.4175L45.317 2.07103Z" fill="#3ECF8E"/>
+<defs>
+<linearGradient id="paint0_linear" x1="53.9738" y1="54.974" x2="94.1635" y2="71.8295" gradientUnits="userSpaceOnUse">
+<stop stop-color="#249361"/>
+<stop offset="1" stop-color="#3ECF8E"/>
+</linearGradient>
+<linearGradient id="paint1_linear" x1="36.1558" y1="30.578" x2="54.4844" y2="65.0806" gradientUnits="userSpaceOnUse">
+<stop/>
+<stop offset="1" stop-opacity="0"/>
+</linearGradient>
+</defs>
+</svg>