deepanalysts 0.2.0__tar.gz → 0.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepanalysts
-Version: 0.2.0
+Version: 0.2.1
 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.0 → deepanalysts-0.2.1}/deepanalysts/backends/basement.py

@@ -130,14 +130,10 @@ class BasementSkillsLoader:
         )
 
         # 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(user_id="user-123", 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(user_id="user-123", agent_name="technical_analyst")
         ```
     """
 
@@ -147,6 +143,7 @@ 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:
@@ -157,6 +154,9 @@ class BasementSkillsLoader:
             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.
@@ -165,6 +165,7 @@ class BasementSkillsLoader:
         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 []
@@ -234,15 +235,17 @@ class BasementSkillsLoader:
                 if not name or not description:
                     continue
 
-                skills.append({
-                    "name": name,
-                    "description": description,
-                    "content": content,
-                    "path": f"/skills/{name}",
-                    "target_agents": [],  # Built-in skills available to all agents
-                    "metadata": frontmatter.get("metadata", {}),
-                    "assets": [],
-                })
+                skills.append(
+                    {
+                        "name": name,
+                        "description": description,
+                        "content": content,
+                        "path": f"/skills/{name}",
+                        "target_agents": [],  # Built-in skills available to all agents
+                        "metadata": frontmatter.get("metadata", {}),
+                        "assets": [],
+                    }
+                )
 
         self._built_in_cache = skills
         logger.debug(f"Loaded {len(skills)} built-in skills from filesystem")
@@ -289,8 +292,7 @@ class BasementSkillsLoader:
         # 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
+                f"{user_id}:{self._get_store_path(skill)}/SKILL.md" not in self._written_skills
                 for skill in all_skills
                 if skill.get("path")
             )
@@ -305,9 +307,7 @@ class BasementSkillsLoader:
             if self._skill_matches_agent(skill, agent_name):
                 filtered.append(self._to_skill_metadata(skill))
 
-        logger.debug(
-            f"Filtered {len(filtered)}/{len(all_skills)} skills for agent '{agent_name}'"
-        )
+        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:
@@ -323,7 +323,7 @@ class BasementSkillsLoader:
 
         from deepanalysts.backends.utils import create_file_data
 
-        namespace = (user_id, "filesystem")
+        namespace = (user_id, self._store_namespace)
 
         # Collect all put operations for batch execution
         put_ops: list[PutOp] = []
@@ -354,9 +354,7 @@ class BasementSkillsLoader:
                         "created_at": file_data["created_at"],
                         "modified_at": file_data["modified_at"],
                     }
-                    put_ops.append(
-                        PutOp(namespace=namespace, key=file_path, value=store_value)
-                    )
+                    put_ops.append(PutOp(namespace=namespace, key=file_path, value=store_value))
                     cache_keys_to_add.append(cache_key)
 
             # Process assets
@@ -377,9 +375,7 @@ class BasementSkillsLoader:
 
                 # 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)
-                    )
+                    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("/")
@@ -420,9 +416,7 @@ class BasementSkillsLoader:
                         "created_at": file_data["created_at"],
                         "modified_at": file_data["modified_at"],
                     }
-                    put_ops.append(
-                        PutOp(namespace=namespace, key=full_path, value=store_value)
-                    )
+                    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
@@ -430,9 +424,7 @@ class BasementSkillsLoader:
             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}"
-            )
+            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.

{deepanalysts-0.2.0 → deepanalysts-0.2.1}/deepanalysts/backends/sandbox.py

@@ -230,9 +230,7 @@ except PermissionError:
 
     def read(self, file_path: str, offset: int = 0, limit: int = 2000) -> str:
         """Read file content with line numbers."""
-        cmd = _READ_COMMAND_TEMPLATE.format(
-            file_path=file_path, offset=offset, limit=limit
-        )
+        cmd = _READ_COMMAND_TEMPLATE.format(file_path=file_path, offset=offset, limit=limit)
         result = self.execute(cmd)
 
         output = result.output.rstrip()
@@ -324,9 +322,7 @@ except PermissionError:
         for line in output.split("\n"):
             parts = line.split(":", 2)
             if len(parts) >= 3:
-                matches.append(
-                    {"path": parts[0], "line": int(parts[1]), "text": parts[2]}
-                )
+                matches.append({"path": parts[0], "line": int(parts[1]), "text": parts[2]})
 
         return matches
 
@@ -483,23 +479,13 @@ class RestrictedSubprocessBackend(BaseSandbox):
             try:
                 file_path = self._temp_dir / path.lstrip("/")
                 if not file_path.exists():
-                    responses.append(
-                        FileDownloadResponse(
-                            path=path, content=None, error="file_not_found"
-                        )
-                    )
+                    responses.append(FileDownloadResponse(path=path, content=None, error="file_not_found"))
                     continue
 
                 content = file_path.read_bytes()
-                responses.append(
-                    FileDownloadResponse(path=path, content=content, error=None)
-                )
+                responses.append(FileDownloadResponse(path=path, content=content, error=None))
             except Exception:
-                responses.append(
-                    FileDownloadResponse(
-                        path=path, content=None, error="permission_denied"
-                    )
-                )
+                responses.append(FileDownloadResponse(path=path, content=None, error="permission_denied"))
 
         return responses
 

{deepanalysts-0.2.0 → deepanalysts-0.2.1}/deepanalysts/middleware/_utils.py

@@ -19,9 +19,7 @@ def append_to_system_message(
     Returns:
         New SystemMessage with the text appended.
     """
-    new_content: list[str | dict[str, str]] = (
-        list(system_message.content_blocks) if system_message else []
-    )
+    new_content: list[str | dict[str, str]] = list(system_message.content_blocks) if system_message else []
     if new_content:
         text = f"\n\n{text}"
     new_content.append({"type": "text", "text": text})

{deepanalysts-0.2.0 → deepanalysts-0.2.1}/deepanalysts/middleware/memory.py

@@ -152,9 +152,7 @@ class MemoryMiddleware(AgentMiddleware):
         self.loader = loader
         self.system_prompt_template = MEMORY_SYSTEM_PROMPT
 
-    def _get_backend(
-        self, state: MemoryState, runtime: Runtime, config: RunnableConfig
-    ) -> BackendProtocol:
+    def _get_backend(self, state: MemoryState, runtime: Runtime, config: RunnableConfig) -> BackendProtocol:
         """Resolve backend from instance or factory.
 
         Args:
@@ -246,9 +244,7 @@ class MemoryMiddleware(AgentMiddleware):
         results = await backend.adownload_files([path])
         # Should get exactly one response for one path
         if len(results) != 1:
-            raise AssertionError(
-                f"Expected 1 response for path {path}, got {len(results)}"
-            )
+            raise AssertionError(f"Expected 1 response for path {path}, got {len(results)}")
         response = results[0]
 
         if response.error is not None:
@@ -276,9 +272,7 @@ class MemoryMiddleware(AgentMiddleware):
         results = backend.download_files([path])
         # Should get exactly one response for one path
         if len(results) != 1:
-            raise AssertionError(
-                f"Expected 1 response for path {path}, got {len(results)}"
-            )
+            raise AssertionError(f"Expected 1 response for path {path}, got {len(results)}")
         response = results[0]
 
         if response.error is not None:
@@ -289,9 +283,7 @@ class MemoryMiddleware(AgentMiddleware):
 
         return None
 
-    def before_agent(
-        self, state: MemoryState, runtime: Runtime, config: RunnableConfig
-    ) -> MemoryStateUpdate | None:
+    def before_agent(self, state: MemoryState, runtime: Runtime, config: RunnableConfig) -> MemoryStateUpdate | None:
         """Load memory content before agent execution (synchronous).
 
         Loads memory from all configured sources and stores in state.
@@ -384,9 +376,7 @@ class MemoryMiddleware(AgentMiddleware):
             memory_contents=memory_contents,
         )
 
-        system_message = append_to_system_message(
-            request.system_message, memory_section
-        )
+        system_message = append_to_system_message(request.system_message, memory_section)
         return request.override(system_message=system_message)
 
     def wrap_model_call(

{deepanalysts-0.2.0 → deepanalysts-0.2.1}/deepanalysts/middleware/patch_tool_calls.py

@@ -43,11 +43,7 @@ class PatchToolCallsMiddleware(AgentMiddleware):
             if msg.type == "ai" and msg.tool_calls:
                 for tool_call in msg.tool_calls:
                     corresponding_tool_msg = next(
-                        (
-                            m
-                            for m in messages[i:]
-                            if m.type == "tool" and m.tool_call_id == tool_call["id"]
-                        ),
+                        (m for m in messages[i:] if m.type == "tool" and m.tool_call_id == tool_call["id"]),
                         None,
                     )
                     if corresponding_tool_msg is None:

{deepanalysts-0.2.0 → deepanalysts-0.2.1}/deepanalysts/middleware/skills.py

@@ -182,9 +182,7 @@ def _parse_skill_metadata(
         SkillMetadata if parsing succeeds, None if parsing fails or validation errors occur
     """
     if len(content) > MAX_SKILL_FILE_SIZE:
-        logger.warning(
-            "Skipping %s: content too large (%d bytes)", skill_path, len(content)
-        )
+        logger.warning("Skipping %s: content too large (%d bytes)", skill_path, len(content))
         return None
 
     # Match YAML frontmatter between --- delimiters
@@ -213,9 +211,7 @@ def _parse_skill_metadata(
     description = frontmatter_data.get("description")
 
     if not name or not description:
-        logger.warning(
-            "Skipping %s: missing required 'name' or 'description'", skill_path
-        )
+        logger.warning("Skipping %s: missing required 'name' or 'description'", skill_path)
         return None
 
     # Validate name format per spec (warn but continue loading for backwards compatibility)
@@ -299,9 +295,7 @@ def _list_skills(backend: BackendProtocol, source_path: str) -> list[SkillMetada
     responses = backend.download_files(paths_to_download)
 
     # Parse each downloaded SKILL.md
-    for (skill_dir_path, skill_md_path), response in zip(
-        skill_md_paths, responses, strict=True
-    ):
+    for (skill_dir_path, skill_md_path), response in zip(skill_md_paths, responses, strict=True):
         if response.error:
             # Skill doesn't have a SKILL.md, skip it
             continue
@@ -331,9 +325,7 @@ def _list_skills(backend: BackendProtocol, source_path: str) -> list[SkillMetada
     return skills
 
 
-async def _alist_skills(
-    backend: BackendProtocol, source_path: str
-) -> list[SkillMetadata]:
+async def _alist_skills(backend: BackendProtocol, source_path: str) -> list[SkillMetadata]:
     """List all skills from a backend source (async version).
 
     Scans backend for subdirectories containing SKILL.md files, downloads their content,
@@ -378,9 +370,7 @@ async def _alist_skills(
     responses = await backend.adownload_files(paths_to_download)
 
     # Parse each downloaded SKILL.md
-    for (skill_dir_path, skill_md_path), response in zip(
-        skill_md_paths, responses, strict=True
-    ):
+    for (skill_dir_path, skill_md_path), response in zip(skill_md_paths, responses, strict=True):
         if response.error:
             # Skill doesn't have a SKILL.md, skip it
             continue
@@ -479,9 +469,7 @@ class SkillsMiddleware(AgentMiddleware):
         self.agent_name = agent_name
         self.system_prompt_template = SKILLS_SYSTEM_PROMPT
 
-    def _get_backend(
-        self, state: SkillsState, runtime: Runtime, config: RunnableConfig
-    ) -> BackendProtocol:
+    def _get_backend(self, state: SkillsState, runtime: Runtime, config: RunnableConfig) -> BackendProtocol:
         """Resolve backend from instance or factory.
 
         Args:
@@ -504,9 +492,7 @@ class SkillsMiddleware(AgentMiddleware):
             )
             backend = self._backend(tool_runtime)
             if backend is None:
-                raise AssertionError(
-                    "SkillsMiddleware requires a valid backend instance"
-                )
+                raise AssertionError("SkillsMiddleware requires a valid backend instance")
             return backend
 
         return self._backend
@@ -560,14 +546,10 @@ class SkillsMiddleware(AgentMiddleware):
             skills_list=skills_list,
         )
 
-        system_message = append_to_system_message(
-            request.system_message, skills_section
-        )
+        system_message = append_to_system_message(request.system_message, skills_section)
         return request.override(system_message=system_message)
 
-    def before_agent(
-        self, state: SkillsState, runtime: Runtime, config: RunnableConfig
-    ) -> SkillsStateUpdate | None:
+    def before_agent(self, state: SkillsState, runtime: Runtime, config: RunnableConfig) -> SkillsStateUpdate | None:
         """Load skills metadata before agent execution (synchronous).
 
         Runs before each agent interaction to discover available skills from all
@@ -634,14 +616,9 @@ class SkillsMiddleware(AgentMiddleware):
         if self.loader:
             # Get user_id for store namespace (multi-tenant isolation)
             user_id = config.get("configurable", {}).get("user_id")
-            skills_metadata = await self.loader.load_skills(
-                agent_name=self.agent_name, user_id=user_id
-            )
+            skills_metadata = await self.loader.load_skills(agent_name=self.agent_name, user_id=user_id)
             if skills_metadata:
-                logger.debug(
-                    f"Loaded {len(skills_metadata)} skills from API "
-                    f"for agent '{self.agent_name}'"
-                )
+                logger.debug(f"Loaded {len(skills_metadata)} skills from API for agent '{self.agent_name}'")
 
         # Also load from backend/sources (for built-in skills and file-based skills)
         if self._backend and self.sources:

{deepanalysts-0.2.0 → deepanalysts-0.2.1}/deepanalysts/middleware/summarization.py

@@ -162,13 +162,9 @@ class SummarizationMiddleware(BaseSummarizationMiddleware):
             self._truncation_text = "...(argument truncated)"
         else:
             self._truncate_args_trigger = truncate_args_settings.get("trigger")
-            self._truncate_args_keep = truncate_args_settings.get(
-                "keep", ("messages", 20)
-            )
+            self._truncate_args_keep = truncate_args_settings.get("keep", ("messages", 20))
             self._max_arg_length = truncate_args_settings.get("max_length", 2000)
-            self._truncation_text = truncate_args_settings.get(
-                "truncation_text", "...(argument truncated)"
-            )
+            self._truncation_text = truncate_args_settings.get("truncation_text", "...(argument truncated)")
 
     def _get_backend(
         self,
@@ -255,9 +251,7 @@ class SummarizationMiddleware(BaseSummarizationMiddleware):
         """
         return [msg for msg in messages if not self._is_summary_message(msg)]
 
-    def _build_new_messages_with_path(
-        self, summary: str, file_path: str | None
-    ) -> list[AnyMessage]:
+    def _build_new_messages_with_path(self, summary: str, file_path: str | None) -> list[AnyMessage]:
         """Build the summary message with optional file path reference.
 
         Args:
@@ -290,9 +284,7 @@ class SummarizationMiddleware(BaseSummarizationMiddleware):
             )
         ]
 
-    def _should_truncate_args(
-        self, messages: list[AnyMessage], total_tokens: int
-    ) -> bool:
+    def _should_truncate_args(self, messages: list[AnyMessage], total_tokens: int) -> bool:
         """Check if argument truncation should be triggered.
 
         Args:
@@ -399,9 +391,7 @@ class SummarizationMiddleware(BaseSummarizationMiddleware):
             }
         return tool_call
 
-    def _truncate_args(
-        self, messages: list[AnyMessage]
-    ) -> tuple[list[AnyMessage], bool]:
+    def _truncate_args(self, messages: list[AnyMessage]) -> tuple[list[AnyMessage], bool]:
         """Truncate large tool call arguments in old messages.
 
         Only truncates arguments for write_file and edit_file tool calls,
@@ -485,11 +475,7 @@ class SummarizationMiddleware(BaseSummarizationMiddleware):
         existing_content = ""
         try:
             responses = backend.download_files([path])
-            if (
-                responses
-                and responses[0].content is not None
-                and responses[0].error is None
-            ):
+            if responses and responses[0].content is not None and responses[0].error is None:
                 existing_content = responses[0].content.decode("utf-8")
         except Exception as e:
             logger.debug(
@@ -560,11 +546,7 @@ class SummarizationMiddleware(BaseSummarizationMiddleware):
         existing_content = ""
         try:
             responses = await backend.adownload_files([path])
-            if (
-                responses
-                and responses[0].content is not None
-                and responses[0].error is None
-            ):
+            if responses and responses[0].content is not None and responses[0].error is None:
                 existing_content = responses[0].content.decode("utf-8")
         except Exception as e:
             logger.debug(
@@ -660,9 +642,7 @@ class SummarizationMiddleware(BaseSummarizationMiddleware):
                 }
             return None
 
-        messages_to_summarize, preserved_messages = self._partition_messages(
-            truncated_messages, cutoff_index
-        )
+        messages_to_summarize, preserved_messages = self._partition_messages(truncated_messages, cutoff_index)
 
         # Offload to backend first - warn if this fails but continue with summarization
         backend = self._get_backend(state, runtime)
@@ -743,9 +723,7 @@ class SummarizationMiddleware(BaseSummarizationMiddleware):
                 }
             return None
 
-        messages_to_summarize, preserved_messages = self._partition_messages(
-            truncated_messages, cutoff_index
-        )
+        messages_to_summarize, preserved_messages = self._partition_messages(truncated_messages, cutoff_index)
 
         # Offload to backend first - warn if this fails but continue with summarization
         backend = self._get_backend(state, runtime)

{deepanalysts-0.2.0 → deepanalysts-0.2.1}/deepanalysts.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepanalysts
-Version: 0.2.0
+Version: 0.2.1
 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.0 → deepanalysts-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepanalysts"
-version = "0.2.0"
+version = "0.2.1"
 description = "LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support"
 readme = "README.md"
 license = { text = "MIT" }

{deepanalysts-0.2.0 → deepanalysts-0.2.1}/tests/test_basement.py

@@ -120,9 +120,7 @@ async def test_basement_skills_loader_assets_to_store():
             "deepanalysts.backends.basement.basement_client.get_active_skills",
             new_callable=AsyncMock,
         ) as mock_get_skills,
-        patch.object(
-            BasementSkillsLoader, "_download_asset", new_callable=AsyncMock
-        ) as mock_download,
+        patch.object(BasementSkillsLoader, "_download_asset", new_callable=AsyncMock) as mock_download,
     ):
         mock_get_skills.return_value = mock_skills
         mock_download.return_value = "print('hello')"
@@ -191,9 +189,7 @@ async def test_basement_skills_loader_filters_by_agent():
         mock_get_skills.return_value = mock_skills
 
         # Load for technical_analyst
-        skills = await loader.load_skills(
-            agent_name="technical_analyst", user_id=user_id
-        )
+        skills = await loader.load_skills(agent_name="technical_analyst", user_id=user_id)
 
         # Should get shared-skill and ta-only-skill, but NOT other-skill
         skill_names = [s["name"] for s in skills]
@@ -230,9 +226,7 @@ async def test_basement_skills_loader_wildcard_target():
         mock_get_skills.return_value = mock_skills
 
         # Should match any agent due to wildcard
-        skills = await loader.load_skills(
-            agent_name="any_agent", user_id="test-user-123"
-        )
+        skills = await loader.load_skills(agent_name="any_agent", user_id="test-user-123")
 
         assert len(skills) == 1
         assert skills[0]["name"] == "wildcard-skill"
@@ -290,3 +284,42 @@ async def test_basement_skills_loader_caching():
         loader.clear_cache()
         await loader.load_skills(agent_name="ta", user_id="user1")
         assert mock_get_skills.call_count == 2
+
+
+@pytest.mark.anyio
+async def test_basement_skills_loader_custom_store_namespace():
+    """Test BasementSkillsLoader writes to custom namespace when store_namespace is set."""
+    mock_skills = [
+        {
+            "name": "ns-skill",
+            "path": "/skills/ns-skill",
+            "content": "# Namespaced Skill",
+            "target_agents": [],
+            "assets": [],
+        }
+    ]
+
+    store = InMemoryStore()
+    jwt_token = "jwt"
+
+    loader = BasementSkillsLoader(
+        store=store,
+        store_namespace="skills",
+        token_provider=lambda: jwt_token,
+    )
+
+    with patch(
+        "deepanalysts.backends.basement.basement_client.get_active_skills",
+        new_callable=AsyncMock,
+    ) as mock_get_skills:
+        mock_get_skills.return_value = mock_skills
+        await loader.load_skills(agent_name="orchestrator", user_id="user-abc")
+
+    # Verify data is in the custom namespace, not "filesystem"
+    custom_ns = await store.aget(("user-abc", "skills"), "/ns-skill/SKILL.md")
+    assert custom_ns is not None
+    assert "Namespaced Skill" in "\n".join(custom_ns.value["content"])
+
+    # Verify data is NOT in the default namespace
+    default_ns = await store.aget(("user-abc", "filesystem"), "/ns-skill/SKILL.md")
+    assert default_ns is None

{deepanalysts-0.2.0 → deepanalysts-0.2.1}/tests/test_filesystem_middleware.py

@@ -73,9 +73,7 @@ class TestReadFileTruncation:
         result = _invoke_read_file(middleware, file_path)
 
         # Result must not exceed the budget
-        assert len(result) <= max_chars, (
-            f"Result length {len(result)} exceeds budget {max_chars}"
-        )
+        assert len(result) <= max_chars, f"Result length {len(result)} exceeds budget {max_chars}"
 
         # Truncation message should be present
         assert "[Output was truncated due to size limits" in result

{deepanalysts-0.2.0 → deepanalysts-0.2.1}/tests/test_sandbox_backend.py

@@ -4,7 +4,6 @@ Tests the sandbox backend's execute() method with timeout handling,
 math calculations, and error capture.
 """
 
-
 from deepanalysts.backends.sandbox import RestrictedSubprocessBackend
 
 
@@ -41,9 +40,7 @@ class TestRestrictedSubprocessBackend:
     def test_execute_captures_stderr(self):
         """Test stderr is captured in output."""
         backend = RestrictedSubprocessBackend()
-        result = backend.execute(
-            "python3 -c \"import sys; print('error', file=sys.stderr)\""
-        )
+        result = backend.execute("python3 -c \"import sys; print('error', file=sys.stderr)\"")
         assert "error" in result.output
 
     def test_execute_fibonacci_calculation(self):

{deepanalysts-0.2.0 → deepanalysts-0.2.1}/tests/test_skills_middleware.py

@@ -4,7 +4,6 @@ from typing import Any
 from unittest.mock import AsyncMock, MagicMock
 
 import pytest
-
 from deepanalysts.middleware.skills import SkillMetadata, SkillsMiddleware
 
 
@@ -42,9 +41,7 @@ class TestSkillsMiddlewareDualLoading:
     """Tests for the dual loader + backend/sources merging behavior."""
 
     @pytest.mark.anyio
-    async def test_loader_only(
-        self, mock_runtime: MagicMock, mock_config: dict
-    ) -> None:
+    async def test_loader_only(self, mock_runtime: MagicMock, mock_config: dict) -> None:
         """Test that loader-only mode works (no backend/sources)."""
         api_skill = _make_skill("api-skill", "From API", "/skills/api-skill/SKILL.md")
         loader = AsyncMock()
@@ -60,9 +57,7 @@ class TestSkillsMiddlewareDualLoading:
         assert result["skills_metadata"] == []
 
     @pytest.mark.anyio
-    async def test_async_loader_only(
-        self, mock_runtime: MagicMock, mock_config: dict
-    ) -> None:
+    async def test_async_loader_only(self, mock_runtime: MagicMock, mock_config: dict) -> None:
         """Test that async loader-only mode works (no backend/sources)."""
         api_skill = _make_skill("api-skill", "From API", "/skills/api-skill/SKILL.md")
         loader = AsyncMock()
@@ -79,23 +74,17 @@ class TestSkillsMiddlewareDualLoading:
         assert skills[0]["name"] == "api-skill"
 
     @pytest.mark.anyio
-    async def test_backend_only(
-        self, mock_runtime: MagicMock, mock_config: dict, tmp_path: Any
-    ) -> None:
+    async def test_backend_only(self, mock_runtime: MagicMock, mock_config: dict, tmp_path: Any) -> None:
         """Test that backend-only mode works (no loader)."""
         # Create a skill directory structure on disk
         skill_dir = tmp_path / "skills" / "disk-skill"
         skill_dir.mkdir(parents=True)
-        (skill_dir / "SKILL.md").write_text(
-            "---\nname: disk-skill\ndescription: From disk\n---\nContent"
-        )
+        (skill_dir / "SKILL.md").write_text("---\nname: disk-skill\ndescription: From disk\n---\nContent")
 
         from deepanalysts.backends import FilesystemBackend
 
         backend = FilesystemBackend()
-        middleware = SkillsMiddleware(
-            backend=backend, sources=[str(tmp_path / "skills")]
-        )
+        middleware = SkillsMiddleware(backend=backend, sources=[str(tmp_path / "skills")])
 
         state: dict[str, Any] = {"messages": []}
         result = await middleware.abefore_agent(state, mock_runtime, mock_config)
@@ -118,9 +107,7 @@ class TestSkillsMiddlewareDualLoading:
         # Disk skill via backend
         skill_dir = tmp_path / "skills" / "disk-skill"
         skill_dir.mkdir(parents=True)
-        (skill_dir / "SKILL.md").write_text(
-            "---\nname: disk-skill\ndescription: From disk\n---\nContent"
-        )
+        (skill_dir / "SKILL.md").write_text("---\nname: disk-skill\ndescription: From disk\n---\nContent")
 
         from deepanalysts.backends import FilesystemBackend
 
@@ -148,18 +135,14 @@ class TestSkillsMiddlewareDualLoading:
     ) -> None:
         """Test that API skills override backend skills with same name."""
         # API skill with name "shared-skill"
-        api_skill = _make_skill(
-            "shared-skill", "API version", "/api/shared-skill/SKILL.md"
-        )
+        api_skill = _make_skill("shared-skill", "API version", "/api/shared-skill/SKILL.md")
         loader = AsyncMock()
         loader.load_skills = AsyncMock(return_value=[api_skill])
 
         # Disk skill with same name
         skill_dir = tmp_path / "skills" / "shared-skill"
         skill_dir.mkdir(parents=True)
-        (skill_dir / "SKILL.md").write_text(
-            "---\nname: shared-skill\ndescription: Disk version\n---\nContent"
-        )
+        (skill_dir / "SKILL.md").write_text("---\nname: shared-skill\ndescription: Disk version\n---\nContent")
 
         from deepanalysts.backends import FilesystemBackend
 
@@ -183,9 +166,7 @@ class TestSkillsMiddlewareDualLoading:
         assert shared[0]["description"] == "API version"
 
     @pytest.mark.anyio
-    async def test_skips_if_already_in_state(
-        self, mock_runtime: MagicMock, mock_config: dict
-    ) -> None:
+    async def test_skips_if_already_in_state(self, mock_runtime: MagicMock, mock_config: dict) -> None:
         """Test that loading is skipped if skills_metadata already in state."""
         loader = AsyncMock()
         loader.load_skills = AsyncMock(return_value=[])

{deepanalysts-0.2.0 → deepanalysts-0.2.1}/tests/test_summarization_middleware.py

@@ -47,9 +47,7 @@ def make_conversation_messages(
                 AIMessage(
                     content=f"AI response {i}",
                     id=f"ai-{i}",
-                    tool_calls=[
-                        {"id": f"tool-call-{i}", "name": "test_tool", "args": {}}
-                    ],
+                    tool_calls=[{"id": f"tool-call-{i}", "name": "test_tool", "args": {}}],
                 )
             )
         else:
@@ -63,9 +61,7 @@ def make_conversation_messages(
 
     for i in range(num_recent):
         idx = num_old + i
-        messages.append(
-            HumanMessage(content=f"Recent message {idx}", id=f"recent-{idx}")
-        )
+        messages.append(HumanMessage(content=f"Recent message {idx}", id=f"recent-{idx}"))
 
     return messages
 
@@ -129,17 +125,13 @@ class MockBackend(BackendProtocol):
     async def awrite(self, path: str, content: str) -> WriteResult:
         return self.write(path, content)
 
-    def edit(
-        self, path: str, old_string: str, new_string: str, replace_all: bool = False
-    ) -> EditResult:
+    def edit(self, path: str, old_string: str, new_string: str, replace_all: bool = False) -> EditResult:
         self.edit_calls.append((path, old_string, new_string))
         if self.should_fail:
             return EditResult(error=self.error_message or "Mock edit failure")
         return EditResult(path=path, occurrences=1)
 
-    async def aedit(
-        self, path: str, old_string: str, new_string: str, replace_all: bool = False
-    ) -> EditResult:
+    async def aedit(self, path: str, old_string: str, new_string: str, replace_all: bool = False) -> EditResult:
         return self.edit(path, old_string, new_string, replace_all)
 
 
@@ -255,7 +247,8 @@ class TestOffloadingBasic:
         assert result is not None
         # Summary message should not include file path (since offload failed)
         summary_msgs = [
-            m for m in result["messages"]
+            m
+            for m in result["messages"]
             if hasattr(m, "additional_kwargs") and m.additional_kwargs.get("lc_source") == "summarization"
         ]
         assert len(summary_msgs) == 1