deepanalysts 0.2.1__tar.gz → 0.2.3__tar.gz

{deepanalysts-0.2.1 → deepanalysts-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepanalysts
-Version: 0.2.1
+Version: 0.2.3
 Summary: LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support
 Author-email: Ganchuluun Narantsatsralt <tsatsralt@swifttech.cloud>
 License: MIT

{deepanalysts-0.2.1 → deepanalysts-0.2.3}/deepanalysts/backends/__init__.py

@@ -28,6 +28,7 @@ from deepanalysts.backends.store import (
     StoreBackend,
     _validate_namespace,
 )
+from deepanalysts.backends.supabase_storage import SupabaseStorageBackend
 
 __all__ = [
     # Protocols and types
@@ -60,6 +61,7 @@ __all__ = [
     "RestrictedSubprocessBackend",
     "StateBackend",
     "StoreBackend",
+    "SupabaseStorageBackend",
 ]
 
 # Optional imports that require additional dependencies (Basement API loaders)

{deepanalysts-0.2.1 → deepanalysts-0.2.3}/deepanalysts/backends/basement.py

@@ -14,14 +14,11 @@ import logging
 import re
 from collections.abc import Callable
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
+from typing import Any, Protocol, runtime_checkable
 
 from deepanalysts.clients.basement import BasementClient, basement_client
 from deepanalysts.middleware.skills import SkillMetadata
 
-if TYPE_CHECKING:
-    from langgraph.store.base import BaseStore
-
 logger = logging.getLogger(__name__)
 
 
@@ -113,9 +110,10 @@ class BasementSkillsLoader:
 
     Fetches active skills via GET /api/v1/skills/active and filters them
     based on target_agents to ensure each subagent only sees relevant skills.
+    Returns SkillMetadata for system prompt injection via SkillsMiddleware.
 
-    Optionally writes skill content to a LangGraph Store so the `read_file` tool
-    can access skill files during conversations.
+    Agents read skill *content* via ``read_file("/skills/...")`` through
+    SupabaseStorageBackend — this loader only provides metadata.
 
     Filtering logic:
     - Empty target_agents = load for all agents
@@ -124,16 +122,13 @@ class BasementSkillsLoader:
 
     Example:
         ```python
-        loader = BasementSkillsLoader(
-            token_provider=get_jwt_from_context,
-            store=app.state.store,
-        )
+        loader = BasementSkillsLoader(token_provider=get_jwt_from_context)
 
         # For orchestrator (all skills without specific targeting)
-        orchestrator_skills = await loader.load_skills(user_id="user-123", agent_name="orchestrator")
+        orchestrator_skills = await loader.load_skills(agent_name="orchestrator")
 
         # For technical analyst (only skills targeting technical_analyst)
-        ta_skills = await loader.load_skills(user_id="user-123", agent_name="technical_analyst")
+        ta_skills = await loader.load_skills(agent_name="technical_analyst")
         ```
     """
 
@@ -142,32 +137,19 @@ class BasementSkillsLoader:
         *,
         client: BasementClient | None = None,
         token_provider: Callable[[], str | None] | None = None,
-        store: BaseStore | None = None,
-        store_namespace: str = "filesystem",
-        supabase_url: str | None = None,
         built_in_dirs: list[str] | None = None,
     ) -> None:
-        """Initialize loader with optional store for caching.
+        """Initialize the skills loader.
 
         Args:
             client: BasementClient instance to use. Defaults to global basement_client.
             token_provider: Callable that returns JWT token.
-            store: LangGraph Store instance for writing skill content.
-                   If None, skills won't be available via read_file.
-            store_namespace: Second element of the store namespace tuple.
-                   Skills are written to ``(user_id, store_namespace)``.
-                   Defaults to ``"filesystem"`` for backward compatibility.
-            supabase_url: Supabase URL for asset downloads. Required if store is provided.
             built_in_dirs: Directories containing built-in skills (SKILL.md files).
                           These are loaded from the filesystem and merged with API skills.
         """
         self._client = client or basement_client
         self._token_provider = token_provider
         self._cache: dict[str, list[dict[str, Any]]] = {}
-        self._store = store
-        self._store_namespace = store_namespace
-        self._supabase_url = supabase_url
-        self._written_skills: set[str] = set()  # Track which skills already written
         self._built_in_dirs = built_in_dirs or []
         self._built_in_cache: list[dict[str, Any]] | None = None
 
@@ -258,11 +240,13 @@ class BasementSkillsLoader:
     ) -> list[SkillMetadata]:
         """Load skills filtered for specific agent.
 
-        Writes skill content to store for read_file access if store is configured.
+        Fetches skill metadata from Basement API for system prompt injection.
+        Agents read skill *content* via ``read_file("/skills/...")`` through
+        the SupabaseStorageBackend — no store caching needed here.
 
         Args:
             agent_name: Agent to filter skills for (e.g., 'technical_analyst').
-            user_id: User ID for store namespace (multi-tenant isolation).
+            user_id: User ID (kept for API compatibility, not used for storage).
 
         Returns:
             List of SkillMetadata dicts filtered by target_agents.
@@ -289,18 +273,6 @@ class BasementSkillsLoader:
             if bi_skill["name"] not in api_names:
                 all_skills.append(bi_skill)
 
-        # Write skills to store for read_file access (only on first load per user)
-        if self._store and user_id:
-            needs_write = any(
-                f"{user_id}:{self._get_store_path(skill)}/SKILL.md" not in self._written_skills
-                for skill in all_skills
-                if skill.get("path")
-            )
-            if needs_write:
-                await self._write_skills_to_store(all_skills, user_id)
-        elif not user_id and self._store:
-            logger.warning("No user_id provided to load_skills, skipping store write")
-
         # Filter by target_agents and convert to SkillMetadata
         filtered: list[SkillMetadata] = []
         for skill in all_skills:
@@ -310,166 +282,6 @@ class BasementSkillsLoader:
         logger.debug(f"Filtered {len(filtered)}/{len(all_skills)} skills for agent '{agent_name}'")
         return filtered
 
-    async def _write_skills_to_store(self, skills: list[dict[str, Any]], user_id: str) -> None:
-        """Write skill content and assets to Store for read_file access.
-
-        Args:
-            skills: List of skill dicts from Basement API.
-            user_id: User ID for store namespace.
-        """
-        import asyncio
-
-        from langgraph.store.base import PutOp
-
-        from deepanalysts.backends.utils import create_file_data
-
-        namespace = (user_id, self._store_namespace)
-
-        # Collect all put operations for batch execution
-        put_ops: list[PutOp] = []
-        cache_keys_to_add: list[str] = []
-
-        # Collect asset download tasks for parallel execution
-        asset_download_tasks: list[tuple[str, str, str, str]] = []
-
-        for skill in skills:
-            skill_path = skill.get("path", "")
-            content = skill.get("content", "")
-
-            if not skill_path:
-                continue
-
-            # Strip /skills/ prefix for store
-            store_skill_path = self._get_store_path(skill)
-
-            # Queue SKILL.md write
-            if content:
-                file_path = store_skill_path.rstrip("/") + "/SKILL.md"
-                cache_key = f"{user_id}:{file_path}"
-
-                if cache_key not in self._written_skills:
-                    file_data = create_file_data(content)
-                    store_value = {
-                        "content": file_data["content"],
-                        "created_at": file_data["created_at"],
-                        "modified_at": file_data["modified_at"],
-                    }
-                    put_ops.append(PutOp(namespace=namespace, key=file_path, value=store_value))
-                    cache_keys_to_add.append(cache_key)
-
-            # Process assets
-            assets = skill.get("assets", []) or skill.get("skill_assets", []) or []
-            for asset in assets:
-                asset_path = asset.get("path", "")
-                asset_type = asset.get("type", "")
-                storage_path = asset.get("storage_path", "")
-
-                if not asset_path or not storage_path:
-                    continue
-
-                full_path = store_skill_path.rstrip("/") + "/" + asset_path.lstrip("/")
-                cache_key = f"{user_id}:{full_path}"
-
-                if cache_key in self._written_skills:
-                    continue
-
-                # Queue text asset downloads for parallel execution
-                if asset_type in ("script", "markdown"):
-                    asset_download_tasks.append((full_path, cache_key, storage_path, asset_type))
-                # For images, create reference file immediately (no download needed)
-                elif asset_type == "image" and self._supabase_url:
-                    supabase_url = self._supabase_url.rstrip("/")
-                    public_url = f"{supabase_url}/storage/v1/object/public/skill-assets/{storage_path}"
-                    ref_content = f"# Image Asset Reference\n\nURL: {public_url}\nType: {asset.get('mime_type', 'image')}\nSize: {asset.get('size_bytes', 0)} bytes"
-                    file_data = create_file_data(ref_content)
-                    store_value = {
-                        "content": file_data["content"],
-                        "created_at": file_data["created_at"],
-                        "modified_at": file_data["modified_at"],
-                    }
-                    put_ops.append(
-                        PutOp(
-                            namespace=namespace,
-                            key=full_path + ".ref",
-                            value=store_value,
-                        )
-                    )
-                    cache_keys_to_add.append(cache_key)
-
-        # Download text assets in parallel
-        if asset_download_tasks:
-            download_results = await asyncio.gather(
-                *[self._download_asset(task[2]) for task in asset_download_tasks],
-                return_exceptions=True,
-            )
-
-            for (full_path, cache_key, storage_path, _), result in zip(
-                asset_download_tasks, download_results, strict=False
-            ):
-                if isinstance(result, Exception):
-                    logger.warning(f"Failed to download asset {storage_path}: {result}")
-                    continue
-                if result:
-                    file_data = create_file_data(result)
-                    store_value = {
-                        "content": file_data["content"],
-                        "created_at": file_data["created_at"],
-                        "modified_at": file_data["modified_at"],
-                    }
-                    put_ops.append(PutOp(namespace=namespace, key=full_path, value=store_value))
-                    cache_keys_to_add.append(cache_key)
-
-        # Execute all writes in a single batch
-        if put_ops:
-            await self._store.abatch(put_ops)
-            # Update cache after successful batch write
-            self._written_skills.update(cache_keys_to_add)
-            logger.debug(f"Wrote {len(put_ops)} skill files to store for user {user_id}")
-
-    async def _download_asset(self, storage_path: str) -> str | None:
-        """Download text asset from Supabase storage.
-
-        Args:
-            storage_path: Path in Supabase storage bucket.
-
-        Returns:
-            Asset content as string, or None on failure.
-        """
-        if not self._supabase_url:
-            logger.warning("No Supabase URL configured, cannot download asset")
-            return None
-
-        import httpx
-
-        try:
-            supabase_url = self._supabase_url.rstrip("/")
-            url = f"{supabase_url}/storage/v1/object/public/skill-assets/{storage_path}"
-
-            async with httpx.AsyncClient(timeout=30.0) as client:
-                response = await client.get(url)
-                if response.status_code == 200:
-                    return response.text
-                else:
-                    logger.warning(f"Failed to download asset: {response.status_code}")
-                    return None
-        except Exception as e:
-            logger.warning(f"Error downloading asset: {e}")
-            return None
-
-    def _get_store_path(self, skill: dict[str, Any]) -> str:
-        """Get the store path for a skill (without /skills/ prefix).
-
-        Args:
-            skill: Skill dict from API.
-
-        Returns:
-            Store path for the skill.
-        """
-        skill_path = skill.get("path", "")
-        if skill_path.startswith("/skills/"):
-            return skill_path[len("/skills/") - 1 :]  # Keep leading /
-        return skill_path
-
     def _skill_matches_agent(self, skill: dict[str, Any], agent_name: str) -> bool:
         """Check if skill should be loaded for given agent.
 
@@ -526,9 +338,8 @@ class BasementSkillsLoader:
         )
 
     def clear_cache(self) -> None:
-        """Clear the skills cache and written tracking."""
+        """Clear the skills cache."""
         self._cache.clear()
-        self._written_skills.clear()
         self._built_in_cache = None