deepanalysts 0.2.4__tar.gz → 0.3.0__tar.gz

{deepanalysts-0.2.4 → deepanalysts-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepanalysts
-Version: 0.2.4
+Version: 0.3.0
 Summary: LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support
 Author-email: Ganchuluun Narantsatsralt <tsatsralt@swifttech.cloud>
 License: MIT
@@ -19,7 +19,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: <4.0,>=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: langchain<2.0.0,>=1.2.3
-Requires-Dist: langgraph>=0.2.0
+Requires-Dist: langgraph>=1.2.0
 Requires-Dist: httpx>=0.28.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: tenacity>=8.2.0

{deepanalysts-0.2.4 → deepanalysts-0.3.0}/deepanalysts/__init__.py

@@ -39,6 +39,12 @@ from deepanalysts.middleware import (
     ToolErrorHandlingMiddleware,
     TruncateArgsSettings,
 )
+from deepanalysts.state import DEFAULT_SNAPSHOT_FREQUENCY, DeepAnalystsState
+from deepanalysts.streaming import (
+    AsyncSubagentRunStream,
+    SubagentRunStream,
+    SubagentTransformer,
+)
 
 __all__ = [
     # Middleware classes
@@ -49,6 +55,13 @@ __all__ = [
     "SubAgentMiddleware",
     "SummarizationMiddleware",
     "ToolErrorHandlingMiddleware",
+    # State
+    "DeepAnalystsState",
+    "DEFAULT_SNAPSHOT_FREQUENCY",
+    # Streaming
+    "AsyncSubagentRunStream",
+    "SubagentRunStream",
+    "SubagentTransformer",
     # TypedDicts and types
     "CompiledSubAgent",
     "SkillMetadata",

deepanalysts-0.3.0/deepanalysts/_messages_reducer.py

@@ -0,0 +1,101 @@
+"""Local `DeltaChannel` reducer for the messages key.
+
+Adapted from langgraph's `_messages_delta_reducer` (PR #7729) and ported from
+upstream `deepagents` (`deepagents/_messages_reducer.py`).
+
+Why a local copy instead of delegating to `langgraph.graph.message._messages_delta_reducer`:
+
+- Upstream is flagged **Experimental** in its docstring.
+- Upstream does NOT handle `REMOVE_ALL_MESSAGES`, missing-id UUID assignment,
+  or `BaseMessageChunk` conversion. We need the first two for parity with
+  `add_messages` behaviour that callers depend on.
+- Upstream always calls `convert_to_messages(flat)` — we skip that on the
+  steady-state path when writes are already typed `BaseMessage` instances.
+- Upstream always rebuilds the final list via a filter comprehension. We
+  short-circuit when no `RemoveMessage` was applied (the append-only common
+  case for `create_agent`).
+
+Pair this with `langgraph.channels.delta.DeltaChannel(snapshot_frequency=N)`
+on a typed-dict messages key (see `deepanalysts.state.DeepAnalystsState`).
+That cuts checkpoint write growth from O(N²) to O(N) per turn, which matters
+for long Park threads persisted to Supabase.
+"""
+
+from __future__ import annotations
+
+import uuid
+from typing import Any, cast
+
+from langchain_core.messages import (
+    AnyMessage,
+    BaseMessage,
+    RemoveMessage,
+    convert_to_messages,
+)
+from langgraph.graph.message import REMOVE_ALL_MESSAGES
+
+
+def _messages_delta_reducer(
+    state: list[AnyMessage], writes: list[list[AnyMessage]]
+) -> list[AnyMessage]:
+    """Batch reducer for use with `DeltaChannel` on the messages key.
+
+    Dedups by ID, tombstones via `RemoveMessage`, resets on
+    `REMOVE_ALL_MESSAGES`. ID-less messages are assigned a UUID before being
+    appended, matching the behaviour of `add_messages`.
+
+    Raw dict / string / tuple inputs are coerced to typed `BaseMessage` so
+    HTTP-driven graphs work without a separate coercion step.
+    """
+    flat: list[Any] = []
+    for w in writes:
+        if isinstance(w, list):
+            flat.extend(w)
+        else:
+            flat.append(w)
+    # Steady-state fast path: every reducer output is already a typed
+    # `BaseMessage`. We probe only `state[0]` / `flat[0]` (all-or-nothing
+    # invariant); callers that seed graph state with a mix of types pay
+    # the slow path on first reduction and stay typed thereafter.
+    state_msgs = state if state and isinstance(state[0], BaseMessage) else cast("list[AnyMessage]", convert_to_messages(state))
+    msgs = flat if flat and isinstance(flat[0], BaseMessage) else cast("list[AnyMessage]", convert_to_messages(flat))
+
+    remove_all_idx = None
+    for idx, m in enumerate(msgs):
+        if isinstance(m, RemoveMessage) and m.id == REMOVE_ALL_MESSAGES:
+            remove_all_idx = idx
+    if remove_all_idx is not None:
+        state_msgs = []
+        msgs = msgs[remove_all_idx + 1 :]
+
+    result: list[AnyMessage | None] = []
+    index: dict[str, int] = {}
+    for m in state_msgs:
+        if m.id is None:
+            m.id = str(uuid.uuid4())
+        index[m.id] = len(result)
+        result.append(m)
+    had_removal = False
+    for msg in msgs:
+        mid = msg.id
+        if mid is None:
+            msg.id = str(uuid.uuid4())
+            mid = msg.id
+            index[mid] = len(result)
+            result.append(msg)
+        elif isinstance(msg, RemoveMessage):
+            if mid in index:
+                result[index[mid]] = None
+                del index[mid]
+                had_removal = True
+        elif mid in index:
+            result[index[mid]] = msg
+        else:
+            index[mid] = len(result)
+            result.append(msg)
+    # Append-only is the common case — skip the filter rebuild when nothing
+    # was tombstoned. cast() is safe: `result` only holds `None` after a
+    # `RemoveMessage` was applied, which we just verified did not happen.
+    if not had_removal:
+        return cast("list[AnyMessage]", result)
+    return [m for m in result if m is not None]

{deepanalysts-0.2.4 → deepanalysts-0.3.0}/deepanalysts/backends/composite.py

@@ -18,7 +18,10 @@ from deepanalysts.backends.protocol import (
     FileDownloadResponse,
     FileInfo,
     FileUploadResponse,
+    GlobResult,
     GrepMatch,
+    GrepResult,
+    LsResult,
     SandboxBackendProtocol,
     WriteResult,
 )
@@ -130,22 +133,28 @@ class CompositeBackend(SandboxBackendProtocol):
     # Sync protocol methods
     # ------------------------------------------------------------------
 
-    def ls_info(self, path: str) -> list[FileInfo]:
+    def ls(self, path: str) -> LsResult:
         backend, backend_path, route_prefix = self._route(path)
 
         if route_prefix is not None:
-            infos = backend.ls_info(backend_path)
-            return [_remap_file_info_path(fi, route_prefix) for fi in infos]
+            child = backend.ls(backend_path)
+            if child.error is not None:
+                return child
+            entries = [_remap_file_info_path(fi, route_prefix) for fi in (child.entries or [])]
+            return LsResult(entries=entries)
 
         # At root, aggregate default and virtual route directories
         if path == "/":
-            results: list[FileInfo] = list(self.default.ls_info(path))
+            default_result = self.default.ls(path)
+            if default_result.error is not None:
+                return default_result
+            results: list[FileInfo] = list(default_result.entries or [])
             for rp, _b in self.sorted_routes:
                 results.append({"path": rp, "is_dir": True, "size": 0, "modified_at": ""})
             results.sort(key=lambda x: x.get("path", ""))
-            return results
+            return LsResult(entries=results)
 
-        return self.default.ls_info(path)
+        return self.default.ls(path)
 
     def read(self, file_path: str, offset: int = 0, limit: int = 2000) -> str:
         backend, backend_path, _rp = self._route(file_path)
@@ -165,57 +174,63 @@ class CompositeBackend(SandboxBackendProtocol):
         backend, backend_path, _rp = self._route(file_path)
         return backend.edit(backend_path, old_string, new_string, replace_all=replace_all)
 
-    def grep_raw(
+    def grep(
         self,
         pattern: str,
         path: str | None = None,
         glob: str | None = None,
-    ) -> list[GrepMatch] | str:
+    ) -> GrepResult:
         # If path targets a specific route, search only that backend
         if path is not None:
             for route_prefix, backend in self.sorted_routes:
                 if path.startswith(route_prefix.rstrip("/")):
                     search_path = path[len(route_prefix) - 1 :] or "/"
-                    raw = backend.grep_raw(pattern, search_path, glob)
-                    if isinstance(raw, str):
-                        return raw
-                    return [_remap_grep_path(m, route_prefix) for m in raw]
+                    child = backend.grep(pattern, search_path, glob)
+                    if child.error is not None:
+                        return child
+                    return GrepResult(matches=[_remap_grep_path(m, route_prefix) for m in (child.matches or [])])
 
         # Search default + all routed backends
         if path is None or path == "/":
-            all_matches: list[GrepMatch] = []
-            raw_default = self.default.grep_raw(pattern, path, glob)
-            if isinstance(raw_default, str):
-                return raw_default
-            all_matches.extend(raw_default)
+            default_result = self.default.grep(pattern, path, glob)
+            if default_result.error is not None:
+                return default_result
+            all_matches: list[GrepMatch] = list(default_result.matches or [])
 
             for route_prefix, backend in self.routes.items():
-                raw = backend.grep_raw(pattern, "/", glob)
-                if isinstance(raw, str):
-                    return raw
-                all_matches.extend(_remap_grep_path(m, route_prefix) for m in raw)
+                child = backend.grep(pattern, "/", glob)
+                if child.error is not None:
+                    return child
+                all_matches.extend(_remap_grep_path(m, route_prefix) for m in (child.matches or []))
 
-            return all_matches
+            return GrepResult(matches=all_matches)
 
-        return self.default.grep_raw(pattern, path, glob)
+        return self.default.grep(pattern, path, glob)
 
-    def glob_info(self, pattern: str, path: str = "/") -> list[FileInfo]:
+    def glob(self, pattern: str, path: str = "/") -> GlobResult:
         for route_prefix, backend in self.sorted_routes:
             if path.startswith(route_prefix.rstrip("/")):
                 search_path = path[len(route_prefix) - 1 :] or "/"
                 stripped = _strip_route_from_pattern(pattern, route_prefix)
-                infos = backend.glob_info(stripped, search_path)
-                return [_remap_file_info_path(fi, route_prefix) for fi in infos]
+                child = backend.glob(stripped, search_path)
+                if child.error is not None:
+                    return child
+                return GlobResult(matches=[_remap_file_info_path(fi, route_prefix) for fi in (child.matches or [])])
 
-        results: list[FileInfo] = list(self.default.glob_info(pattern, path))
+        default_result = self.default.glob(pattern, path)
+        if default_result.error is not None:
+            return default_result
+        results: list[FileInfo] = list(default_result.matches or [])
 
         for route_prefix, backend in self.routes.items():
             stripped = _strip_route_from_pattern(pattern, route_prefix)
-            infos = backend.glob_info(stripped, "/")
-            results.extend(_remap_file_info_path(fi, route_prefix) for fi in infos)
+            child = backend.glob(stripped, "/")
+            if child.error is not None:
+                return child
+            results.extend(_remap_file_info_path(fi, route_prefix) for fi in (child.matches or []))
 
         results.sort(key=lambda x: x.get("path", ""))
-        return results
+        return GlobResult(matches=results)
 
     def execute(self, command: str) -> ExecuteResponse:
         if isinstance(self.default, SandboxBackendProtocol):
@@ -247,21 +262,27 @@ class CompositeBackend(SandboxBackendProtocol):
     # which fails on async-only backends like SupabaseStorageBackend.
     # ------------------------------------------------------------------
 
-    async def als_info(self, path: str) -> list[FileInfo]:
+    async def als(self, path: str) -> LsResult:
         backend, backend_path, route_prefix = self._route(path)
 
         if route_prefix is not None:
-            infos = await backend.als_info(backend_path)
-            return [_remap_file_info_path(fi, route_prefix) for fi in infos]
+            child = await backend.als(backend_path)
+            if child.error is not None:
+                return child
+            entries = [_remap_file_info_path(fi, route_prefix) for fi in (child.entries or [])]
+            return LsResult(entries=entries)
 
         if path == "/":
-            results: list[FileInfo] = list(await self.default.als_info(path))
+            default_result = await self.default.als(path)
+            if default_result.error is not None:
+                return default_result
+            results: list[FileInfo] = list(default_result.entries or [])
             for rp, _b in self.sorted_routes:
                 results.append({"path": rp, "is_dir": True, "size": 0, "modified_at": ""})
             results.sort(key=lambda x: x.get("path", ""))
-            return results
+            return LsResult(entries=results)
 
-        return await self.default.als_info(path)
+        return await self.default.als(path)
 
     async def aread(self, file_path: str, offset: int = 0, limit: int = 2000) -> str:
         backend, backend_path, _rp = self._route(file_path)
@@ -281,55 +302,61 @@ class CompositeBackend(SandboxBackendProtocol):
         backend, backend_path, _rp = self._route(file_path)
         return await backend.aedit(backend_path, old_string, new_string, replace_all=replace_all)
 
-    async def agrep_raw(
+    async def agrep(
         self,
         pattern: str,
         path: str | None = None,
         glob: str | None = None,
-    ) -> list[GrepMatch] | str:
+    ) -> GrepResult:
         if path is not None:
             for route_prefix, backend in self.sorted_routes:
                 if path.startswith(route_prefix.rstrip("/")):
                     search_path = path[len(route_prefix) - 1 :] or "/"
-                    raw = await backend.agrep_raw(pattern, search_path, glob)
-                    if isinstance(raw, str):
-                        return raw
-                    return [_remap_grep_path(m, route_prefix) for m in raw]
+                    child = await backend.agrep(pattern, search_path, glob)
+                    if child.error is not None:
+                        return child
+                    return GrepResult(matches=[_remap_grep_path(m, route_prefix) for m in (child.matches or [])])
 
         if path is None or path == "/":
-            all_matches: list[GrepMatch] = []
-            raw_default = await self.default.agrep_raw(pattern, path, glob)
-            if isinstance(raw_default, str):
-                return raw_default
-            all_matches.extend(raw_default)
+            default_result = await self.default.agrep(pattern, path, glob)
+            if default_result.error is not None:
+                return default_result
+            all_matches: list[GrepMatch] = list(default_result.matches or [])
 
             for route_prefix, backend in self.routes.items():
-                raw = await backend.agrep_raw(pattern, "/", glob)
-                if isinstance(raw, str):
-                    return raw
-                all_matches.extend(_remap_grep_path(m, route_prefix) for m in raw)
+                child = await backend.agrep(pattern, "/", glob)
+                if child.error is not None:
+                    return child
+                all_matches.extend(_remap_grep_path(m, route_prefix) for m in (child.matches or []))
 
-            return all_matches
+            return GrepResult(matches=all_matches)
 
-        return await self.default.agrep_raw(pattern, path, glob)
+        return await self.default.agrep(pattern, path, glob)
 
-    async def aglob_info(self, pattern: str, path: str = "/") -> list[FileInfo]:
+    async def aglob(self, pattern: str, path: str = "/") -> GlobResult:
         for route_prefix, backend in self.sorted_routes:
             if path.startswith(route_prefix.rstrip("/")):
                 search_path = path[len(route_prefix) - 1 :] or "/"
                 stripped = _strip_route_from_pattern(pattern, route_prefix)
-                infos = await backend.aglob_info(stripped, search_path)
-                return [_remap_file_info_path(fi, route_prefix) for fi in infos]
+                child = await backend.aglob(stripped, search_path)
+                if child.error is not None:
+                    return child
+                return GlobResult(matches=[_remap_file_info_path(fi, route_prefix) for fi in (child.matches or [])])
 
-        results: list[FileInfo] = list(await self.default.aglob_info(pattern, path))
+        default_result = await self.default.aglob(pattern, path)
+        if default_result.error is not None:
+            return default_result
+        results: list[FileInfo] = list(default_result.matches or [])
 
         for route_prefix, backend in self.routes.items():
             stripped = _strip_route_from_pattern(pattern, route_prefix)
-            infos = await backend.aglob_info(stripped, "/")
-            results.extend(_remap_file_info_path(fi, route_prefix) for fi in infos)
+            child = await backend.aglob(stripped, "/")
+            if child.error is not None:
+                return child
+            results.extend(_remap_file_info_path(fi, route_prefix) for fi in (child.matches or []))
 
         results.sort(key=lambda x: x.get("path", ""))
-        return results
+        return GlobResult(matches=results)
 
     async def aupload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
         results: list[FileUploadResponse | None] = [None] * len(files)

{deepanalysts-0.2.4 → deepanalysts-0.3.0}/deepanalysts/backends/filesystem.py

@@ -31,7 +31,10 @@ from deepanalysts.backends.protocol import (
     FileInfo,
     FileOperationError,
     FileUploadResponse,
+    GlobResult,
     GrepMatch,
+    GrepResult,
+    LsResult,
     WriteResult,
 )
 from deepanalysts.backends.utils import check_empty_content, perform_string_replacement
@@ -137,18 +140,18 @@ class LocalFilesystemBackend(BackendProtocol):
         root = self._root or Path.cwd()
         return "/" + path.resolve().relative_to(root).as_posix()
 
-    def ls_info(self, path: str) -> list[FileInfo]:
+    def ls(self, path: str) -> LsResult:
         """List files in a directory.
 
         Args:
             path: Directory path to list.
 
         Returns:
-            List of FileInfo dicts with path, is_dir, size, modified_at.
+            `LsResult` with entries (path, is_dir, size, modified_at).
         """
         resolved = self._resolve_path(path)
         if not resolved.exists() or not resolved.is_dir():
-            return []
+            return LsResult(entries=[])
 
         results: list[FileInfo] = []
         try:
@@ -182,7 +185,7 @@ class LocalFilesystemBackend(BackendProtocol):
             pass
 
         results.sort(key=lambda x: x.get("path", ""))
-        return results
+        return LsResult(entries=results)
 
     def read(self, file_path: str, offset: int = 0, limit: int = 2000) -> str:
         """Read file content with line numbers.
@@ -328,12 +331,12 @@ class LocalFilesystemBackend(BackendProtocol):
 
         return EditResult(path=str(resolved), occurrences=int(occurrences))
 
-    def grep_raw(
+    def grep(
         self,
         pattern: str,
         path: str | None = None,
         glob: str | None = None,
-    ) -> list[GrepMatch] | str:
+    ) -> GrepResult:
         """Search for literal text pattern in files.
 
         Tries ripgrep first (``rg -F`` for literal mode), falls back to
@@ -345,24 +348,24 @@ class LocalFilesystemBackend(BackendProtocol):
             glob: File pattern to match.
 
         Returns:
-            List of matches or error string.
+            `GrepResult` with matches or error.
         """
         try:
             search_path = self._resolve_path(path or ".")
         except ValueError:
-            return []
+            return GrepResult(matches=[])
 
         if not search_path.exists():
-            return []
+            return GrepResult(matches=[])
 
         # Try ripgrep first
         rg_results = self._ripgrep_search(pattern, search_path, glob)
         if rg_results is not None:
-            return self._results_to_matches(rg_results)
+            return GrepResult(matches=self._results_to_matches(rg_results))
 
         # Python fallback with max_file_size protection
         py_results = self._python_search(re.escape(pattern), search_path, glob)
-        return self._results_to_matches(py_results)
+        return GrepResult(matches=self._results_to_matches(py_results))
 
     def _ripgrep_search(
         self, pattern: str, base: Path, include_glob: str | None
@@ -470,7 +473,7 @@ class LocalFilesystemBackend(BackendProtocol):
                 matches.append({"path": fpath, "line": int(line_num), "text": line_text})
         return matches
 
-    def glob_info(self, pattern: str, path: str = "/") -> list[FileInfo]:
+    def glob(self, pattern: str, path: str = "/") -> GlobResult:
         """Find files matching glob pattern.
 
         Args:
@@ -478,21 +481,21 @@ class LocalFilesystemBackend(BackendProtocol):
             path: Base path.
 
         Returns:
-            List of matching FileInfo.
+            `GlobResult` with matching FileInfo entries.
         """
         if pattern.startswith("/"):
             pattern = pattern.lstrip("/")
 
         if self._virtual_mode and ".." in Path(pattern).parts:
-            return []
+            return GlobResult(matches=[])
 
         try:
             search_path = self._resolve_path(path)
         except ValueError:
-            return []
+            return GlobResult(matches=[])
 
         if not search_path.exists():
-            return []
+            return GlobResult(matches=[])
 
         results: list[FileInfo] = []
         try:
@@ -523,7 +526,7 @@ class LocalFilesystemBackend(BackendProtocol):
             pass
 
         results.sort(key=lambda x: x.get("path", ""))
-        return results
+        return GlobResult(matches=results)
 
     def execute(self, command: str, timeout: int = 120) -> ExecuteResponse:
         """Execute a shell command.