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

intentkit/skills/firecrawl/utils.py

@@ -1,11 +1,9 @@
 """Utilities for Firecrawl skill content indexing and querying."""
 
 import logging
-import pickle
 import re
 from typing import Any, Dict, List, Optional, Tuple
 
-import faiss
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 from langchain_community.vectorstores import FAISS
 from langchain_core.documents import Document
@@ -77,46 +75,52 @@ class FirecrawlVectorStoreManager:
             openai_api_key=openai_api_key, model="text-embedding-3-small"
         )
 
-    def encode_vector_store(self, vector_store: FAISS) -> Dict[str, bytes]:
-        """Encode FAISS vector store to bytes for storage."""
-        try:
-            # Serialize the index
-            index_bytes = faiss.serialize_index(vector_store.index)
-
-            # Serialize the docstore and index_to_docstore_id
-            docstore_bytes = pickle.dumps(vector_store.docstore)
-            index_to_docstore_bytes = pickle.dumps(vector_store.index_to_docstore_id)
+    def encode_vector_store(self, vector_store: FAISS) -> Dict[str, str]:
+        """Encode FAISS vector store to base64 for storage (compatible with web_scraper)."""
+        import base64
+        import os
+        import tempfile
 
-            return {
-                "index": index_bytes,
-                "docstore": docstore_bytes,
-                "index_to_docstore": index_to_docstore_bytes,
-            }
+        try:
+            with tempfile.TemporaryDirectory() as temp_dir:
+                vector_store.save_local(temp_dir)
+
+                encoded_files = {}
+                for filename in os.listdir(temp_dir):
+                    file_path = os.path.join(temp_dir, filename)
+                    if os.path.isfile(file_path):
+                        with open(file_path, "rb") as f:
+                            encoded_files[filename] = base64.b64encode(f.read()).decode(
+                                "utf-8"
+                            )
+
+                return encoded_files
         except Exception as e:
             logger.error(f"Error encoding vector store: {e}")
             raise
 
     def decode_vector_store(
-        self, faiss_data: Dict[str, bytes], embeddings: OpenAIEmbeddings
+        self, encoded_files: Dict[str, str], embeddings: OpenAIEmbeddings
     ) -> FAISS:
-        """Decode FAISS vector store from stored bytes."""
-        try:
-            # Deserialize the index
-            index = faiss.deserialize_index(faiss_data["index"])
-
-            # Deserialize the docstore and index_to_docstore_id
-            docstore = pickle.loads(faiss_data["docstore"])
-            index_to_docstore_id = pickle.loads(faiss_data["index_to_docstore"])
-
-            # Create FAISS vector store
-            vector_store = FAISS(
-                embedding_function=embeddings,
-                index=index,
-                docstore=docstore,
-                index_to_docstore_id=index_to_docstore_id,
-            )
+        """Decode base64 files back to FAISS vector store (compatible with web_scraper)."""
+        import base64
+        import os
+        import tempfile
 
-            return vector_store
+        try:
+            with tempfile.TemporaryDirectory() as temp_dir:
+                # Decode and write files
+                for filename, encoded_content in encoded_files.items():
+                    file_path = os.path.join(temp_dir, filename)
+                    with open(file_path, "wb") as f:
+                        f.write(base64.b64decode(encoded_content))
+
+                # Load vector store
+                return FAISS.load_local(
+                    temp_dir,
+                    embeddings,
+                    allow_dangerous_deserialization=True,
+                )
         except Exception as e:
             logger.error(f"Error decoding vector store: {e}")
             raise
@@ -124,9 +128,9 @@ class FirecrawlVectorStoreManager:
     async def load_vector_store(self, agent_id: str) -> Optional[FAISS]:
         """Load existing vector store for an agent."""
         try:
-            vector_store_key = f"firecrawl_vector_store_{agent_id}"
+            vector_store_key = f"vector_store_{agent_id}"
             stored_data = await self.skill_store.get_agent_skill_data(
-                agent_id, "firecrawl", vector_store_key
+                agent_id, "web_scraper", vector_store_key
             )
 
             if not stored_data or "faiss_files" not in stored_data:
@@ -139,14 +143,27 @@ class FirecrawlVectorStoreManager:
             logger.error(f"Error loading vector store for agent {agent_id}: {e}")
             return None
 
-    async def save_vector_store(self, agent_id: str, vector_store: FAISS) -> None:
-        """Save vector store for an agent."""
+    async def save_vector_store(
+        self,
+        agent_id: str,
+        vector_store: FAISS,
+        chunk_size: int = 1000,
+        chunk_overlap: int = 200,
+    ) -> None:
+        """Save vector store for an agent (compatible with web_scraper format)."""
         try:
-            vector_store_key = f"firecrawl_vector_store_{agent_id}"
-            encoded_data = self.encode_vector_store(vector_store)
+            vector_store_key = f"vector_store_{agent_id}"
+            encoded_files = self.encode_vector_store(vector_store)
+
+            # Use the same data structure as web_scraper
+            storage_data = {
+                "faiss_files": encoded_files,
+                "chunk_size": chunk_size,
+                "chunk_overlap": chunk_overlap,
+            }
 
             await self.skill_store.save_agent_skill_data(
-                agent_id, "firecrawl", vector_store_key, {"faiss_files": encoded_data}
+                agent_id, "web_scraper", vector_store_key, storage_data
             )
 
         except Exception as e:
@@ -176,9 +193,9 @@ class FirecrawlMetadataManager:
     ) -> None:
         """Update metadata for an agent."""
         try:
-            metadata_key = f"firecrawl_metadata_{agent_id}"
+            metadata_key = f"indexed_urls_{agent_id}"
             await self.skill_store.save_agent_skill_data(
-                agent_id, "firecrawl", metadata_key, new_metadata
+                agent_id, "web_scraper", metadata_key, new_metadata
             )
         except Exception as e:
             logger.error(f"Error updating metadata for agent {agent_id}: {e}")
@@ -235,7 +252,9 @@ async def index_documents(
             was_merged = False
 
         # Save the vector store
-        await vs_manager.save_vector_store(agent_id, vector_store)
+        await vs_manager.save_vector_store(
+            agent_id, vector_store, chunk_size, chunk_overlap
+        )
 
         logger.info(
             f"Successfully indexed {len(split_docs)} chunks for agent {agent_id}"

intentkit/skills/heurist/image_generation_animagine_xl.py

@@ -137,7 +137,7 @@ class ImageGenerationAnimagineXL(HeuristBaseTool):
             # Store the image URL
             image_url = response.text.strip('"')
             # Generate a key with agent ID as prefix
-            image_key = f"{context.agent.id}/heurist/{job_id}"
+            image_key = f"{context.agent_id}/heurist/{job_id}"
             # Store the image and get the CDN URL
             stored_url = await store_image(image_url, image_key)
 

intentkit/skills/heurist/image_generation_arthemy_comics.py

@@ -137,7 +137,7 @@ class ImageGenerationArthemyComics(HeuristBaseTool):
             # Store the image URL
             image_url = response.text.strip('"')
             # Generate a key with agent ID as prefix
-            image_key = f"{context.agent.id}/heurist/{job_id}"
+            image_key = f"{context.agent_id}/heurist/{job_id}"
             # Store the image and get the CDN URL
             stored_url = await store_image(image_url, image_key)
 

intentkit/skills/heurist/image_generation_arthemy_real.py

@@ -137,7 +137,7 @@ class ImageGenerationArthemyReal(HeuristBaseTool):
             # Store the image URL
             image_url = response.text.strip('"')
             # Generate a key with agent ID as prefix
-            image_key = f"{context.agent.id}/heurist/{job_id}"
+            image_key = f"{context.agent_id}/heurist/{job_id}"
             # Store the image and get the CDN URL
             stored_url = await store_image(image_url, image_key)
 

intentkit/skills/heurist/image_generation_braindance.py

@@ -137,7 +137,7 @@ class ImageGenerationBrainDance(HeuristBaseTool):
             # Store the image URL
             image_url = response.text.strip('"')
             # Generate a key with agent ID as prefix
-            image_key = f"{context.agent.id}/heurist/{job_id}"
+            image_key = f"{context.agent_id}/heurist/{job_id}"
             # Store the image and get the CDN URL
             stored_url = await store_image(image_url, image_key)
 

intentkit/skills/heurist/image_generation_cyber_realistic_xl.py

@@ -137,7 +137,7 @@ class ImageGenerationCyberRealisticXL(HeuristBaseTool):
             # Store the image URL
             image_url = response.text.strip('"')
             # Generate a key with agent ID as prefix
-            image_key = f"{context.agent.id}/heurist/{job_id}"
+            image_key = f"{context.agent_id}/heurist/{job_id}"
             # Store the image and get the CDN URL
             stored_url = await store_image(image_url, image_key)
 

intentkit/skills/heurist/image_generation_flux_1_dev.py

@@ -137,7 +137,7 @@ class ImageGenerationFlux1Dev(HeuristBaseTool):
             # Store the image URL
             image_url = response.text.strip('"')
             # Generate a key with agent ID as prefix
-            image_key = f"{context.agent.id}/heurist/{job_id}"
+            image_key = f"{context.agent_id}/heurist/{job_id}"
             # Store the image and get the CDN URL
             stored_url = await store_image(image_url, image_key)
 

intentkit/skills/heurist/image_generation_sdxl.py

@@ -136,7 +136,7 @@ class ImageGenerationSDXL(HeuristBaseTool):
             # Store the image URL
             image_url = response.text.strip('"')
             # Generate a key with agent ID as prefix
-            image_key = f"{context.agent.id}/heurist/{job_id}"
+            image_key = f"{context.agent_id}/heurist/{job_id}"
             # Store the image and get the CDN URL
             stored_url = await store_image(image_url, image_key)
 

intentkit/skills/lifi/token_execute.py

@@ -129,7 +129,7 @@ class TokenExecute(LiFiBaseTool):
 
             # Get agent context for CDP wallet
             context = self.context_from_config(config)
-            agent_id = context.agent.id
+            agent_id = context.agent_id
 
             self.logger.info(
                 f"Executing LiFi transfer: {from_amount} {from_token} on {from_chain} -> {to_token} on {to_chain}"

intentkit/skills/openai/dalle_image_generation.py

@@ -109,7 +109,7 @@ class DALLEImageGeneration(OpenAIBaseTool):
             image_url = image_url.strip('"')
 
             # Generate a key with agent ID as prefix
-            image_key = f"{context.agent.id}/dalle/{job_id}"
+            image_key = f"{context.agent_id}/dalle/{job_id}"
 
             # Store the image and get the CDN URL
             stored_url = await store_image(image_url, image_key)

intentkit/skills/openai/gpt_image_generation.py

@@ -133,7 +133,7 @@ class GPTImageGeneration(OpenAIBaseTool):
             image_bytes = base64.b64decode(base64_image)
 
             # Generate a key with agent ID as prefix
-            image_key = f"{context.agent.id}/gpt-image/{job_id}"
+            image_key = f"{context.agent_id}/gpt-image/{job_id}"
 
             # Store the image bytes and get the CDN URL
             stored_url = await store_image_bytes(image_bytes, image_key, content_type)

intentkit/skills/openai/gpt_image_to_image.py

@@ -157,7 +157,7 @@ class GPTImageToImage(OpenAIBaseTool):
                 image_bytes = base64.b64decode(base64_image)
 
                 # Generate a key with agent ID as prefix
-                image_key = f"{context.agent.id}/gpt-image-edit/{job_id}"
+                image_key = f"{context.agent_id}/gpt-image-edit/{job_id}"
 
                 # Store the image bytes and get the CDN URL
                 stored_url = await store_image_bytes(image_bytes, image_key)

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