deepagents 0.3.3__tar.gz → 0.3.5__tar.gz

{deepagents-0.3.3 → deepagents-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.3.3
+Version: 0.3.5
 Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
 License: MIT
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
@@ -11,10 +11,10 @@ Project-URL: Slack, https://www.langchain.com/join-community
 Project-URL: Reddit, https://www.reddit.com/r/LangChain/
 Requires-Python: <4.0,>=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: langchain-anthropic<2.0.0,>=1.2.0
-Requires-Dist: langchain-google-genai
-Requires-Dist: langchain<2.0.0,>=1.1.0
-Requires-Dist: langchain-core<2.0.0,>=1.2.5
+Requires-Dist: langchain-core<2.0.0,>=1.2.6
+Requires-Dist: langchain<2.0.0,>=1.2.3
+Requires-Dist: langchain-anthropic<2.0.0,>=1.3.1
+Requires-Dist: langchain-google-genai<5.0.0,>=4.1.3
 Requires-Dist: wcmatch
 
 # 🧠🤖Deep Agents

{deepagents-0.3.3 → deepagents-0.3.5}/deepagents/graph.py

@@ -33,7 +33,7 @@ def get_default_model() -> ChatAnthropic:
     """Get the default model for deep agents.
 
     Returns:
-        ChatAnthropic instance configured with Claude Sonnet 4.
+        `ChatAnthropic` instance configured with Claude Sonnet 4.5.
     """
     return ChatAnthropic(
         model_name="claude-sonnet-4-5-20250929",
@@ -62,51 +62,51 @@ def create_deep_agent(
 ) -> CompiledStateGraph:
     """Create a deep agent.
 
-    This agent will by default have access to a tool to write todos (write_todos),
-    seven file and execution tools: ls, read_file, write_file, edit_file, glob, grep, execute,
+    This agent will by default have access to a tool to write todos (`write_todos`),
+    seven file and execution tools: `ls`, `read_file`, `write_file`, `edit_file`, `glob`, `grep`, `execute`,
     and a tool to call subagents.
 
-    The execute tool allows running shell commands if the backend implements SandboxBackendProtocol.
-    For non-sandbox backends, the execute tool will return an error message.
+    The `execute` tool allows running shell commands if the backend implements `SandboxBackendProtocol`.
+    For non-sandbox backends, the `execute` tool will return an error message.
 
     Args:
-        model: The model to use. Defaults to Claude Sonnet 4.
+        model: The model to use. Defaults to `claude-sonnet-4-5-20250929`.
         tools: The tools the agent should have access to.
         system_prompt: The additional instructions the agent should have. Will go in
             the system prompt.
         middleware: Additional middleware to apply after standard middleware.
-        subagents: The subagents to use. Each subagent should be a dictionary with the
-            following keys:
-                - `name`
-                - `description` (used by the main agent to decide whether to call the
-                  sub agent)
-                - `prompt` (used as the system prompt in the subagent)
-                - (optional) `tools`
-                - (optional) `model` (either a LanguageModelLike instance or dict
-                  settings)
-                - (optional) `middleware` (list of AgentMiddleware)
-        skills: Optional list of skill source paths (e.g., ["/skills/user/", "/skills/project/"]).
+        subagents: The subagents to use.
+
+            Each subagent should be a `dict` with the following keys:
+
+            - `name`
+            - `description` (used by the main agent to decide whether to call the sub agent)
+            - `prompt` (used as the system prompt in the subagent)
+            - (optional) `tools`
+            - (optional) `model` (either a `LanguageModelLike` instance or `dict` settings)
+            - (optional) `middleware` (list of `AgentMiddleware`)
+        skills: Optional list of skill source paths (e.g., `["/skills/user/", "/skills/project/"]`).
+
             Paths must be specified using POSIX conventions (forward slashes) and are relative
-            to the backend's root. When using StateBackend (default), provide skill files via
-            `invoke(files={...})`. With FilesystemBackend, skills are loaded from disk relative
-            to the backend's root_dir. Later sources override earlier ones for skills with the
+            to the backend's root. When using `StateBackend` (default), provide skill files via
+            `invoke(files={...})`. With `FilesystemBackend`, skills are loaded from disk relative
+            to the backend's `root_dir`. Later sources override earlier ones for skills with the
             same name (last one wins).
-        memory: Optional list of memory file paths (AGENTS.md files) to load
-            (e.g., ["/memory/AGENTS.md"]). Display names
-            are automatically derived from paths. Memory is loaded at agent startup and
-            added into the system prompt.
+        memory: Optional list of memory file paths (`AGENTS.md` files) to load
+            (e.g., `["/memory/AGENTS.md"]`). Display names are automatically derived from paths.
+            Memory is loaded at agent startup and added into the system prompt.
         response_format: A structured output response format to use for the agent.
         context_schema: The schema of the deep agent.
-        checkpointer: Optional checkpointer for persisting agent state between runs.
-        store: Optional store for persistent storage (required if backend uses StoreBackend).
-        backend: Optional backend for file storage and execution. Pass either a Backend instance
-            or a callable factory like `lambda rt: StateBackend(rt)`. For execution support,
-            use a backend that implements SandboxBackendProtocol.
-        interrupt_on: Optional Dict[str, bool | InterruptOnConfig] mapping tool names to
-            interrupt configs.
-        debug: Whether to enable debug mode. Passed through to create_agent.
-        name: The name of the agent. Passed through to create_agent.
-        cache: The cache to use for the agent. Passed through to create_agent.
+        checkpointer: Optional `Checkpointer` for persisting agent state between runs.
+        store: Optional store for persistent storage (required if backend uses `StoreBackend`).
+        backend: Optional backend for file storage and execution.
+
+            Pass either a `Backend` instance or a callable factory like `lambda rt: StateBackend(rt)`.
+            For execution support, use a backend that implements `SandboxBackendProtocol`.
+        interrupt_on: Mapping of tool names to interrupt configs.
+        debug: Whether to enable debug mode. Passed through to `create_agent`.
+        name: The name of the agent. Passed through to `create_agent`.
+        cache: The cache to use for the agent. Passed through to `create_agent`.
 
     Returns:
         A configured deep agent.

{deepagents-0.3.3 → deepagents-0.3.5}/deepagents/middleware/filesystem.py

@@ -979,30 +979,91 @@ class FilesystemMiddleware(AgentMiddleware):
         message: ToolMessage,
         resolved_backend: BackendProtocol,
     ) -> tuple[ToolMessage, dict[str, FileData] | None]:
-        content = message.content
-        if not isinstance(content, str) or len(content) <= 4 * self.tool_token_limit_before_evict:
+        """Process a large ToolMessage by evicting its content to filesystem.
+
+        Args:
+            message: The ToolMessage with large content to evict.
+            resolved_backend: The filesystem backend to write the content to.
+
+        Returns:
+            A tuple of (processed_message, files_update):
+            - processed_message: New ToolMessage with truncated content and file reference
+            - files_update: Dict of file updates to apply to state, or None if eviction failed
+
+        Note:
+            The entire content is converted to string, written to /large_tool_results/{tool_call_id},
+            and replaced with a truncated preview plus file reference. The replacement is always
+            returned as a plain string for consistency, regardless of original content type.
+
+            ToolMessage supports multimodal content blocks (images, audio, etc.), but these are
+            uncommon in tool results. For simplicity, all content is stringified and evicted.
+            The model can recover by reading the offloaded file from the backend.
+        """
+        # Early exit if eviction not configured
+        if not self.tool_token_limit_before_evict:
             return message, None
 
+        # Convert content to string once for both size check and eviction
+        # Special case: single text block - extract text directly for readability
+        if (
+            isinstance(message.content, list)
+            and len(message.content) == 1
+            and isinstance(message.content[0], dict)
+            and message.content[0].get("type") == "text"
+            and "text" in message.content[0]
+        ):
+            content_str = str(message.content[0]["text"])
+        elif isinstance(message.content, str):
+            content_str = message.content
+        else:
+            # Multiple blocks or non-text content - stringify entire structure
+            content_str = str(message.content)
+
+        # Check if content exceeds eviction threshold
+        # Using 4 chars per token as a conservative approximation (actual ratio varies by content)
+        # This errs on the high side to avoid premature eviction of content that might fit
+        if len(content_str) <= 4 * self.tool_token_limit_before_evict:
+            return message, None
+
+        # Write content to filesystem
         sanitized_id = sanitize_tool_call_id(message.tool_call_id)
         file_path = f"/large_tool_results/{sanitized_id}"
-        result = resolved_backend.write(file_path, content)
+        result = resolved_backend.write(file_path, content_str)
         if result.error:
             return message, None
-        content_sample = format_content_with_line_numbers([line[:1000] for line in content.splitlines()[:10]], start_line=1)
+
+        # Create truncated preview for the replacement message
+        content_sample = format_content_with_line_numbers([line[:1000] for line in content_str.splitlines()[:10]], start_line=1)
+        replacement_text = TOO_LARGE_TOOL_MSG.format(
+            tool_call_id=message.tool_call_id,
+            file_path=file_path,
+            content_sample=content_sample,
+        )
+
+        # Always return as plain string after eviction
         processed_message = ToolMessage(
-            TOO_LARGE_TOOL_MSG.format(
-                tool_call_id=message.tool_call_id,
-                file_path=file_path,
-                content_sample=content_sample,
-            ),
+            content=replacement_text,
             tool_call_id=message.tool_call_id,
         )
         return processed_message, result.files_update
 
     def _intercept_large_tool_result(self, tool_result: ToolMessage | Command, runtime: ToolRuntime) -> ToolMessage | Command:
-        if isinstance(tool_result, ToolMessage) and isinstance(tool_result.content, str):
-            if not (self.tool_token_limit_before_evict and len(tool_result.content) > 4 * self.tool_token_limit_before_evict):
-                return tool_result
+        """Intercept and process large tool results before they're added to state.
+
+        Args:
+            tool_result: The tool result to potentially evict (ToolMessage or Command).
+            runtime: The tool runtime providing access to the filesystem backend.
+
+        Returns:
+            Either the original result (if small enough) or a Command with evicted
+            content written to filesystem and truncated message.
+
+        Note:
+            Handles both single ToolMessage results and Command objects containing
+            multiple messages. Large content is automatically offloaded to filesystem
+            to prevent context window overflow.
+        """
+        if isinstance(tool_result, ToolMessage):
             resolved_backend = self._get_backend(runtime)
             processed_message, files_update = self._process_large_message(
                 tool_result,
@@ -1028,14 +1089,10 @@ class FilesystemMiddleware(AgentMiddleware):
             resolved_backend = self._get_backend(runtime)
             processed_messages = []
             for message in command_messages:
-                if not (
-                    self.tool_token_limit_before_evict
-                    and isinstance(message, ToolMessage)
-                    and isinstance(message.content, str)
-                    and len(message.content) > 4 * self.tool_token_limit_before_evict
-                ):
+                if not isinstance(message, ToolMessage):
                     processed_messages.append(message)
                     continue
+
                 processed_message, files_update = self._process_large_message(
                     message,
                     resolved_backend,
@@ -1044,8 +1101,7 @@ class FilesystemMiddleware(AgentMiddleware):
                 if files_update is not None:
                     accumulated_file_updates.update(files_update)
             return Command(update={**update, "messages": processed_messages, "files": accumulated_file_updates})
-
-        return tool_result
+        raise AssertionError(f"Unreachable code reached in _intercept_large_tool_result: for tool_result of type {type(tool_result)}")
 
     def wrap_tool_call(
         self,

{deepagents-0.3.3 → deepagents-0.3.5}/deepagents/middleware/memory.py

@@ -89,21 +89,65 @@ class MemoryStateUpdate(TypedDict):
     memory_contents: dict[str, str]
 
 
-# Default system prompt template for memory
-MEMORY_SYSTEM_PROMPT = """
-## Agent Memory
-
-You have access to persistent memory that provides context and instructions.
-
-{memory_locations}
-
-{memory_contents}
-
-**Memory Guidelines:**
-- Memory content above provides project-specific context and instructions
-- Follow any guidelines, conventions, or patterns described in memory
-- Memory is read-only during this session (loaded at startup)
-- If you need to update memory, use the appropriate file editing tools
+MEMORY_SYSTEM_PROMPT = """<agent_memory>
+{agent_memory}
+</agent_memory>
+
+<memory_guidelines>
+    The above <agent_memory> was loaded in from files in your filesystem. As you learn from your interactions with the user, you can save new knowledge by calling the `edit_file` tool.
+
+    **Learning from feedback:**
+    - One of your MAIN PRIORITIES is to learn from your interactions with the user. These learnings can be implicit or explicit. This means that in the future, you will remember this important information.
+    - When you need to remember something, updating memory must be your FIRST, IMMEDIATE action - before responding to the user, before calling other tools, before doing anything else. Just update memory immediately.
+    - When user says something is better/worse, capture WHY and encode it as a pattern.
+    - Each correction is a chance to improve permanently - don't just fix the immediate issue, update your instructions.
+    - A great opportunity to update your memories is when the user interrupts a tool call and provides feedback. You should update your memories immediately before revising the tool call.
+    - Look for the underlying principle behind corrections, not just the specific mistake.
+    - The user might not explicitly ask you to remember something, but if they provide information that is useful for future use, you should update your memories immediately.
+
+    **Asking for information:**
+    - If you lack context to perform an action (e.g. send a Slack DM, requires a user ID/email) you should explicitly ask the user for this information.
+    - It is preferred for you to ask for information, don't assume anything that you do not know!
+    - When the user provides information that is useful for future use, you should update your memories immediately.
+
+    **When to update memories:**
+    - When the user explicitly asks you to remember something (e.g., "remember my email", "save this preference")
+    - When the user describes your role or how you should behave (e.g., "you are a web researcher", "always do X")
+    - When the user gives feedback on your work - capture what was wrong and how to improve
+    - When the user provides information required for tool use (e.g., slack channel ID, email addresses)
+    - When the user provides context useful for future tasks, such as how to use tools, or which actions to take in a particular situation
+    - When you discover new patterns or preferences (coding styles, conventions, workflows)
+
+    **When to NOT update memories:**
+    - When the information is temporary or transient (e.g., "I'm running late", "I'm on my phone right now")
+    - When the information is a one-time task request (e.g., "Find me a recipe", "What's 25 * 4?")
+    - When the information is a simple question that doesn't reveal lasting preferences (e.g., "What day is it?", "Can you explain X?")
+    - When the information is an acknowledgment or small talk (e.g., "Sounds good!", "Hello", "Thanks for that")
+    - When the information is stale or irrelevant in future conversations
+    - Never store API keys, access tokens, passwords, or any other credentials in any file, memory, or system prompt.
+    - If the user asks where to put API keys or provides an API key, do NOT echo or save it.
+
+    **Examples:**
+    Example 1 (remembering user information):
+    User: Can you connect to my google account?
+    Agent: Sure, I'll connect to your google account, what's your google account email?
+    User: john@example.com
+    Agent: Let me save this to my memory.
+    Tool Call: edit_file(...) -> remembers that the user's google account email is john@example.com
+
+    Example 2 (remembering implicit user preferences):
+    User: Can you write me an example for creating a deep agent in LangChain?
+    Agent: Sure, I'll write you an example for creating a deep agent in LangChain <example code in Python>
+    User: Can you do this in JavaScript
+    Agent: Let me save this to my memory.
+    Tool Call: edit_file(...) -> remembers that the user prefers to get LangChaincode examples in JavaScript
+    Agent: Sure, here is the JavaScript example<example code in JavaScript>
+
+    Example 3 (do not remember transient information):
+    User: I'm going to play basketball tonight so I will be offline for a few hours.
+    Agent: Okay I'll add a black to your calendar.
+    Tool Call: create_calendar_event(...) -> just calls a tool, does not commit anything to memory, as it is transient information
+</memory_guidelines>
 """
 
 
@@ -137,7 +181,6 @@ class MemoryMiddleware(AgentMiddleware):
         """
         self._backend = backend
         self.sources = sources
-        self.system_prompt_template = MEMORY_SYSTEM_PROMPT
 
     def _get_backend(self, state: MemoryState, runtime: Runtime, config: RunnableConfig) -> BackendProtocol:
         """Resolve backend from instance or factory.
@@ -163,37 +206,28 @@ class MemoryMiddleware(AgentMiddleware):
             return self._backend(tool_runtime)
         return self._backend
 
-    def _format_memory_locations(self) -> str:
-        """Format memory source locations for display."""
-        if not self.sources:
-            return "**Memory Sources:** None configured"
-
-        lines = ["**Memory Sources:**"]
-        for path in self.sources:
-            lines.append(f"- `{path}`")
-        return "\n".join(lines)
-
-    def _format_memory_contents(self, contents: dict[str, str]) -> str:
-        """Format loaded memory contents for injection into prompt.
+    def _format_agent_memory(self, contents: dict[str, str]) -> str:
+        """Format memory with locations and contents paired together.
 
         Args:
             contents: Dict mapping source paths to content.
 
         Returns:
-            Formatted string with all memory contents concatenated.
+            Formatted string with location+content pairs wrapped in <agent_memory> tags.
         """
         if not contents:
-            return "(No memory loaded)"
+            return MEMORY_SYSTEM_PROMPT.format(agent_memory="(No memory loaded)")
 
         sections = []
         for path in self.sources:
             if contents.get(path):
-                sections.append(contents[path])
+                sections.append(f"{path}\n{contents[path]}")
 
         if not sections:
-            return "(No memory loaded)"
+            return MEMORY_SYSTEM_PROMPT.format(agent_memory="(No memory loaded)")
 
-        return "\n\n".join(sections)
+        memory_body = "\n\n".join(sections)
+        return MEMORY_SYSTEM_PROMPT.format(agent_memory=memory_body)
 
     async def _load_memory_from_backend(
         self,
@@ -329,18 +363,12 @@ class MemoryMiddleware(AgentMiddleware):
             Modified request with memory injected into system prompt.
         """
         contents = request.state.get("memory_contents", {})
-        memory_locations = self._format_memory_locations()
-        memory_contents = self._format_memory_contents(contents)
-
-        memory_section = self.system_prompt_template.format(
-            memory_locations=memory_locations,
-            memory_contents=memory_contents,
-        )
+        agent_memory = self._format_agent_memory(contents)
 
         if request.system_prompt:
-            system_prompt = memory_section + "\n\n" + request.system_prompt
+            system_prompt = agent_memory + "\n\n" + request.system_prompt
         else:
-            system_prompt = memory_section
+            system_prompt = agent_memory
 
         return request.override(system_message=SystemMessage(system_prompt))
 

{deepagents-0.3.3 → deepagents-0.3.5}/deepagents.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.3.3
+Version: 0.3.5
 Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
 License: MIT
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
@@ -11,10 +11,10 @@ Project-URL: Slack, https://www.langchain.com/join-community
 Project-URL: Reddit, https://www.reddit.com/r/LangChain/
 Requires-Python: <4.0,>=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: langchain-anthropic<2.0.0,>=1.2.0
-Requires-Dist: langchain-google-genai
-Requires-Dist: langchain<2.0.0,>=1.1.0
-Requires-Dist: langchain-core<2.0.0,>=1.2.5
+Requires-Dist: langchain-core<2.0.0,>=1.2.6
+Requires-Dist: langchain<2.0.0,>=1.2.3
+Requires-Dist: langchain-anthropic<2.0.0,>=1.3.1
+Requires-Dist: langchain-google-genai<5.0.0,>=4.1.3
 Requires-Dist: wcmatch
 
 # 🧠🤖Deep Agents

deepagents-0.3.5/deepagents.egg-info/requires.txt

@@ -0,0 +1,5 @@
+langchain-core<2.0.0,>=1.2.6
+langchain<2.0.0,>=1.2.3
+langchain-anthropic<2.0.0,>=1.3.1
+langchain-google-genai<5.0.0,>=4.1.3
+wcmatch

deepagents-0.3.5/pyproject.toml

@@ -0,0 +1,135 @@
+[project]
+name = "deepagents"
+version = "0.3.5"
+description = "General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11,<4.0"
+dependencies = [
+    "langchain-core>=1.2.6,<2.0.0",
+    "langchain>=1.2.3,<2.0.0",
+    "langchain-anthropic>=1.3.1,<2.0.0",
+    "langchain-google-genai>=4.1.3,<5.0.0",
+    "wcmatch",
+]
+
+
+[project.urls]
+Homepage = "https://docs.langchain.com/oss/python/deepagents/overview"
+Documentation = "https://reference.langchain.com/python/deepagents/"
+Source = "https://github.com/langchain-ai/deepagents"
+Twitter = "https://x.com/LangChainAI"
+Slack = "https://www.langchain.com/join-community"
+Reddit = "https://www.reddit.com/r/LangChain/"
+
+
+[dependency-groups]
+test = [
+  "pytest",
+  "pytest-cov",
+  "pytest-xdist",
+  "ruff>=0.12.2,<0.13.0",
+  "mypy>=1.18.1,<1.19.0",
+  "pytest-asyncio>=1.3.0",
+]
+
+dev = [
+  "langchain-openai",
+  "twine",
+  "build",
+]
+
+[build-system]
+requires = ["setuptools>=73.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.package-data]
+"*" = ["py.typed", "*.md"]
+
+[tool.ruff]
+line-length = 150
+# Exclude any files that shouldn't be linted
+exclude = []
+
+[tool.ruff.format]
+docstring-code-format = true  # Formats code blocks in docstrings
+
+[tool.ruff.lint]
+select = [
+    "ALL"  # Enable all rules by default
+]
+ignore = [
+    "COM812",  # Messes with the formatter
+    "ISC001",  # Messes with the formatter
+    "PERF203", # Rarely useful
+    "SLF001",  # Private member access
+    "PLC0415", # Imports should be at the top. Not always desirable
+    "PLR0913", # Too many arguments in function definition
+    "PLC0414", # Inconsistent with how type checkers expect to be notified of intentional re-exports
+    "C901",    # Too complex
+]
+unfixable = ["B028"]  # Rules that shouldn't be auto-fixed
+
+[tool.ruff.lint.pyupgrade]
+keep-runtime-typing = true
+
+[tool.ruff.lint.flake8-annotations]
+allow-star-arg-any = true
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"  # Google-style docstrings
+ignore-var-parameters = true
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = [
+    "D1",      # Skip documentation rules in tests
+    "S101",    # Allow asserts in tests
+    "S311",    # Allow pseudo-random generators in tests
+    # Add more test-specific ignores
+]
+
+"deepagents/backends/composite.py" = ["B007", "BLE001", "D102", "EM101", "FBT001", "FBT002", "PLW2901", "S110"]
+"deepagents/backends/filesystem.py" = ["BLE001", "D102", "D205", "D417", "DTZ006", "EM101", "EM102", "FBT001", "FBT002", "PLR0912", "S112", "TRY003"]
+"deepagents/backends/protocol.py" = ["B024", "B027", "FBT001", "FBT002"]
+"deepagents/backends/sandbox.py" = ["FBT001", "FBT002", "PLR2004"]
+"deepagents/backends/state.py" = ["ANN204", "D102", "D205", "EM101", "FBT001", "FBT002", "PERF401"]
+"deepagents/backends/store.py" = ["A002", "ANN204", "BLE001", "D102", "D205", "F821", "FBT001", "FBT002", "PERF401"]
+"deepagents/backends/utils.py" = ["D301", "E501", "EM101", "FBT001", "RET504", "RUF005", "TRY003"]
+"deepagents/middleware/filesystem.py" = ["EM102", "TRY003"]
+"deepagents/middleware/memory.py" = ["E501", "EM102", "G004", "PERF401", "SIM108", "T201", "TC002", "TC003", "TRY003"]
+"deepagents/middleware/skills.py" = ["EM101", "SIM108", "TC002", "TC003", "TRY003"]
+"tests/integration_tests/test_deepagents.py" = ["ANN201", "C419", "E731", "PLR2004", "SIM118", "TID252"]
+"tests/integration_tests/test_filesystem_middleware.py" = ["ANN001", "ANN201", "ANN202", "ARG002", "E731", "PLR2004", "SIM118", "T201", "TID252"]
+"tests/integration_tests/test_hitl.py" = ["ANN201", "C419", "E501", "PLR2004", "TID252"]
+"tests/integration_tests/test_subagent_middleware.py" = ["ANN001", "ANN201", "F841", "RUF012", "SIM118"]
+"tests/unit_tests/backends/test_composite_backend.py" = ["ANN001", "ANN201", "ANN202", "ARG001", "ARG002", "F841", "INP001", "PLR2004", "PT018"]
+"tests/unit_tests/backends/test_composite_backend_async.py" = ["ANN001", "ANN201", "ANN202", "ARG001", "ARG002", "F841", "INP001", "PLR2004", "PT018"]
+"tests/unit_tests/backends/test_filesystem_backend.py" = ["ANN201", "ARG005", "B007", "B011", "INP001", "PLR2004", "PT015", "PT018"]
+"tests/unit_tests/backends/test_filesystem_backend_async.py" = ["ANN201", "ARG005", "B007", "INP001", "PLR2004", "PT011", "PT018"]
+"tests/unit_tests/backends/test_state_backend.py" = ["ANN001", "ANN201", "INP001", "PLR2004", "PT018"]
+"tests/unit_tests/backends/test_state_backend_async.py" = ["ANN001", "ANN201", "INP001", "PLR2004", "PT018"]
+"tests/unit_tests/backends/test_store_backend.py" = ["ANN201", "INP001", "PLR2004", "PT018"]
+"tests/unit_tests/backends/test_store_backend_async.py" = ["ANN201", "INP001", "PLR2004", "PT018"]
+"tests/unit_tests/chat_model.py" = ["ARG002", "D301", "PLR0912", "RUF012"]
+"tests/unit_tests/middleware/test_memory_middleware.py" = ["F841", "PGH003", "PLR2004", "RUF001", "TC002"]
+"tests/unit_tests/middleware/test_memory_middleware_async.py" = ["F841", "PGH003", "PLR2004", "RUF001"]
+"tests/unit_tests/middleware/test_skills_middleware.py" = ["F841", "PGH003", "PLR2004", "TC002"]
+"tests/unit_tests/middleware/test_skills_middleware_async.py" = ["F841", "PGH003", "PLR2004"]
+"tests/unit_tests/middleware/test_validate_path.py" = ["ANN201"]
+"tests/unit_tests/test_end_to_end.py" = ["ARG002", "PLR2004"]
+"tests/unit_tests/test_middleware.py" = ["ANN001", "ANN201", "ANN202", "ARG002", "E731", "PLR2004", "SIM118", "T201"]
+"tests/unit_tests/test_middleware_async.py" = ["ANN001", "ANN201", "ANN202", "ARG002"]
+"tests/unit_tests/test_subagents.py" = ["PLR2004"]
+"tests/unit_tests/test_todo_middleware.py" = ["E501", "PLR2004"]
+"tests/utils.py" = ["ANN001", "ANN201", "RUF012", "SIM118"]
+
+[tool.mypy]
+strict = true
+ignore_missing_imports = true
+enable_error_code = ["deprecated"]
+# Optional: reduce strictness if needed
+disallow_any_generics = false
+warn_return_any = false
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

deepagents-0.3.3/deepagents.egg-info/requires.txt

@@ -1,5 +0,0 @@
-langchain-anthropic<2.0.0,>=1.2.0
-langchain-google-genai
-langchain<2.0.0,>=1.1.0
-langchain-core<2.0.0,>=1.2.5
-wcmatch

deepagents-0.3.3/pyproject.toml

@@ -1,100 +0,0 @@
-[project]
-name = "deepagents"
-version = "0.3.3"
-description = "General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph."
-readme = "README.md"
-license = { text = "MIT" }
-requires-python = ">=3.11,<4.0"
-dependencies = [
-    "langchain-anthropic>=1.2.0,<2.0.0",
-    "langchain-google-genai",
-    "langchain>=1.1.0,<2.0.0",
-    "langchain-core>=1.2.5,<2.0.0",
-    "wcmatch",
-]
-
-
-[project.urls]
-Homepage = "https://docs.langchain.com/oss/python/deepagents/overview"
-Documentation = "https://reference.langchain.com/python/deepagents/"
-Source = "https://github.com/langchain-ai/deepagents"
-Twitter = "https://x.com/LangChainAI"
-Slack = "https://www.langchain.com/join-community"
-Reddit = "https://www.reddit.com/r/LangChain/"
-
-
-[dependency-groups]
-test = [
-  "pytest",
-  "pytest-cov",
-  "pytest-xdist",
-  "ruff>=0.12.2,<0.13.0",
-  "mypy>=1.18.1,<1.19.0",
-  "pytest-asyncio>=1.3.0",
-]
-
-dev = [
-  "langchain-openai",
-  "twine",
-  "build",
-]
-
-[build-system]
-requires = ["setuptools>=73.0.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[tool.setuptools.package-data]
-"*" = ["py.typed", "*.md"]
-
-[tool.ruff]
-line-length = 150
-# Exclude any files that shouldn't be linted
-exclude = []
-
-[tool.ruff.format]
-docstring-code-format = true  # Formats code blocks in docstrings
-
-[tool.ruff.lint]
-select = [
-    "ALL"  # Enable all rules by default
-]
-ignore = [
-    "COM812",  # Messes with the formatter
-    "ISC001",  # Messes with the formatter
-    "PERF203", # Rarely useful
-    "SLF001",  # Private member access
-    "PLC0415", # Imports should be at the top. Not always desirable
-    "PLR0913", # Too many arguments in function definition
-    "PLC0414", # Inconsistent with how type checkers expect to be notified of intentional re-exports
-    "C901",    # Too complex
-]
-unfixable = ["B028"]  # Rules that shouldn't be auto-fixed
-
-[tool.ruff.lint.pyupgrade]
-keep-runtime-typing = true
-
-[tool.ruff.lint.flake8-annotations]
-allow-star-arg-any = true
-
-[tool.ruff.lint.pydocstyle]
-convention = "google"  # Google-style docstrings
-ignore-var-parameters = true
-
-[tool.ruff.lint.per-file-ignores]
-"tests/*" = [
-    "D1",      # Skip documentation rules in tests
-    "S101",    # Allow asserts in tests
-    "S311",    # Allow pseudo-random generators in tests
-    # Add more test-specific ignores
-]
-
-[tool.mypy]
-strict = true
-ignore_missing_imports = true
-enable_error_code = ["deprecated"]
-# Optional: reduce strictness if needed
-disallow_any_generics = false
-warn_return_any = false
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"