intentkit 0.5.1__py3-none-any.whl → 0.6.0__py3-none-any.whl

intentkit/skills/supabase/__init__.py

@@ -0,0 +1,116 @@
+"""Supabase skills."""
+
+import logging
+from typing import TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.supabase.base import SupabaseBaseTool
+from intentkit.skills.supabase.delete_data import SupabaseDeleteData
+from intentkit.skills.supabase.fetch_data import SupabaseFetchData
+from intentkit.skills.supabase.insert_data import SupabaseInsertData
+from intentkit.skills.supabase.invoke_function import SupabaseInvokeFunction
+from intentkit.skills.supabase.update_data import SupabaseUpdateData
+from intentkit.skills.supabase.upsert_data import SupabaseUpsertData
+
+# Cache skills at the system level, because they are stateless
+_cache: dict[str, SupabaseBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    fetch_data: SkillState
+    insert_data: SkillState
+    update_data: SkillState
+    upsert_data: SkillState
+    delete_data: SkillState
+    invoke_function: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for Supabase skills."""
+
+    states: SkillStates
+    supabase_url: str
+    supabase_key: str
+    public_write_tables: str = ""
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[SupabaseBaseTool]:
+    """Get all Supabase skills."""
+    available_skills = []
+
+    # Include skills based on their state
+    for skill_name, state in config["states"].items():
+        if state == "disabled":
+            continue
+        elif state == "public" or (state == "private" and is_private):
+            available_skills.append(skill_name)
+
+    # Get each skill using the cached getter
+    result = []
+    for name in available_skills:
+        skill = get_supabase_skill(name, store)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_supabase_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> SupabaseBaseTool:
+    """Get a Supabase skill by name.
+
+    Args:
+        name: The name of the skill to get
+        store: The skill store for persisting data
+
+    Returns:
+        The requested Supabase skill
+    """
+    if name == "fetch_data":
+        if name not in _cache:
+            _cache[name] = SupabaseFetchData(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "insert_data":
+        if name not in _cache:
+            _cache[name] = SupabaseInsertData(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "update_data":
+        if name not in _cache:
+            _cache[name] = SupabaseUpdateData(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "upsert_data":
+        if name not in _cache:
+            _cache[name] = SupabaseUpsertData(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "delete_data":
+        if name not in _cache:
+            _cache[name] = SupabaseDeleteData(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "invoke_function":
+        if name not in _cache:
+            _cache[name] = SupabaseInvokeFunction(
+                skill_store=store,
+            )
+        return _cache[name]
+    else:
+        logger.warning(f"Unknown Supabase skill: {name}")
+        return None

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)}"
+            )