deepagents 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

deepagents/middleware/filesystem.py

@@ -1,12 +1,9 @@
 """Middleware for providing filesystem tools to an agent."""
 # ruff: noqa: E501
 
-from collections.abc import Awaitable, Callable, Sequence
-from typing import Annotated
-from typing_extensions import NotRequired
-
 import os
-from typing import Literal, Optional
+from collections.abc import Awaitable, Callable, Sequence
+from typing import Annotated, Literal, NotRequired
 
 from langchain.agents.middleware.types import (
     AgentMiddleware,
@@ -21,14 +18,13 @@ from langchain_core.tools import BaseTool, tool
 from langgraph.types import Command
 from typing_extensions import TypedDict
 
-from deepagents.backends.protocol import BackendProtocol, BackendFactory, WriteResult, EditResult
 from deepagents.backends import StateBackend
+from deepagents.backends.protocol import BackendFactory, BackendProtocol, EditResult, WriteResult
 from deepagents.backends.utils import (
-    update_file_data,
     format_content_with_line_numbers,
     format_grep_matches,
-    truncate_if_too_long,
     sanitize_tool_call_id,
+    truncate_if_too_long,
 )
 
 EMPTY_CONTENT_WARNING = "System reminder: File exists but has empty contents"
@@ -36,10 +32,7 @@ MAX_LINE_LENGTH = 2000
 LINE_NUMBER_WIDTH = 6
 DEFAULT_READ_OFFSET = 0
 DEFAULT_READ_LIMIT = 500
-BACKEND_TYPES = (
-    BackendProtocol
-    | BackendFactory
-)
+BACKEND_TYPES = BackendProtocol | BackendFactory
 
 
 class FileData(TypedDict):
@@ -135,6 +128,7 @@ def _validate_path(path: str, *, allowed_prefixes: Sequence[str] | None = None)
 
     return normalized
 
+
 class FilesystemState(AgentState):
     """State for the filesystem middleware."""
 
@@ -327,15 +321,17 @@ def _write_file_tool_generator(
             return res.error
         # If backend returns state update, wrap into Command with ToolMessage
         if res.files_update is not None:
-            return Command(update={
-                "files": res.files_update,
-                "messages": [
-                    ToolMessage(
-                        content=f"Updated file {res.path}",
-                        tool_call_id=runtime.tool_call_id,
-                    )
-                ],
-            })
+            return Command(
+                update={
+                    "files": res.files_update,
+                    "messages": [
+                        ToolMessage(
+                            content=f"Updated file {res.path}",
+                            tool_call_id=runtime.tool_call_id,
+                        )
+                    ],
+                }
+            )
         return f"Updated file {res.path}"
 
     return write_file
@@ -371,15 +367,17 @@ def _edit_file_tool_generator(
         if res.error:
             return res.error
         if res.files_update is not None:
-            return Command(update={
-                "files": res.files_update,
-                "messages": [
-                    ToolMessage(
-                        content=f"Successfully replaced {res.occurrences} instance(s) of the string in '{res.path}'",
-                        tool_call_id=runtime.tool_call_id,
-                    )
-                ],
-            })
+            return Command(
+                update={
+                    "files": res.files_update,
+                    "messages": [
+                        ToolMessage(
+                            content=f"Successfully replaced {res.occurrences} instance(s) of the string in '{res.path}'",
+                            tool_call_id=runtime.tool_call_id,
+                        )
+                    ],
+                }
+            )
         return f"Successfully replaced {res.occurrences} instance(s) of the string in '{res.path}'"
 
     return edit_file
@@ -428,7 +426,7 @@ def _grep_tool_generator(
     def grep(
         pattern: str,
         runtime: ToolRuntime[None, FilesystemState],
-        path: Optional[str] = None,
+        path: str | None = None,
         glob: str | None = None,
         output_mode: Literal["files_with_matches", "content", "count"] = "files_with_matches",
     ) -> str:
@@ -509,10 +507,7 @@ class FilesystemMiddleware(AgentMiddleware):
         agent = create_agent(middleware=[FilesystemMiddleware()])
 
         # With hybrid storage (ephemeral + persistent /memories/)
-        backend = CompositeBackend(
-            default=StateBackend(),
-            routes={"/memories/": StoreBackend()}
-        )
+        backend = CompositeBackend(default=StateBackend(), routes={"/memories/": StoreBackend()})
         agent = create_agent(middleware=[FilesystemMiddleware(memory_backend=backend)])
         ```
     """
@@ -608,7 +603,7 @@ class FilesystemMiddleware(AgentMiddleware):
         result = resolved_backend.write(file_path, content)
         if result.error:
             return message, None
-        content_sample = format_content_with_line_numbers(content.splitlines()[:10], start_line=1)
+        content_sample = format_content_with_line_numbers([line[:1000] for line in content.splitlines()[:10]], start_line=1)
         processed_message = ToolMessage(
             TOO_LARGE_TOOL_MSG.format(
                 tool_call_id=message.tool_call_id,
@@ -621,20 +616,25 @@ class FilesystemMiddleware(AgentMiddleware):
 
     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):
+            if not (self.tool_token_limit_before_evict and len(tool_result.content) > 4 * self.tool_token_limit_before_evict):
                 return tool_result
             resolved_backend = self._get_backend(runtime)
             processed_message, files_update = self._process_large_message(
                 tool_result,
                 resolved_backend,
             )
-            return (Command(update={
-                "files": files_update,
-                "messages": [processed_message],
-            }) if files_update is not None else processed_message)
+            return (
+                Command(
+                    update={
+                        "files": files_update,
+                        "messages": [processed_message],
+                    }
+                )
+                if files_update is not None
+                else processed_message
+            )
 
-        elif isinstance(tool_result, Command):
+        if isinstance(tool_result, Command):
             update = tool_result.update
             if update is None:
                 return tool_result
@@ -643,10 +643,12 @@ 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 (
+                    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
+                ):
                     processed_messages.append(message)
                     continue
                 processed_message, files_update = self._process_large_message(

deepagents/middleware/resumable_shell.py

@@ -2,17 +2,18 @@
 
 from __future__ import annotations
 
-from typing import Any, Awaitable, Callable, cast
+from collections.abc import Awaitable, Callable
+from typing import Any, cast
 
 from langchain.agents.middleware.shell_tool import (
     ShellToolMiddleware,
+    ShellToolState,
     _PersistentShellTool,
     _SessionResources,
-    ShellToolState,
 )
 from langchain.agents.middleware.types import AgentState
-from langchain_core.messages import ToolMessage
 from langchain.tools.tool_node import ToolCallRequest
+from langchain_core.messages import ToolMessage
 from langgraph.types import Command
 
 
@@ -78,7 +79,7 @@ class ResumableShellToolMiddleware(ShellToolMiddleware):
             return resources
 
         new_resources = self._create_resources()
-        cast(dict[str, Any], state)["shell_session_resources"] = new_resources
+        cast("dict[str, Any]", state)["shell_session_resources"] = new_resources
         return new_resources
 
 

deepagents/middleware/subagents.py

@@ -1,8 +1,7 @@
 """Middleware for providing subagents to an agent via a `task` tool."""
 
 from collections.abc import Awaitable, Callable, Sequence
-from typing import Any, TypedDict, cast
-from typing_extensions import NotRequired
+from typing import Any, NotRequired, TypedDict, cast
 
 from langchain.agents import create_agent
 from langchain.agents.middleware import HumanInTheLoopMiddleware, InterruptOnConfig

{deepagents-0.2.3.dist-info → deepagents-0.2.5.dist-info}/METADATA

@@ -1,8 +1,14 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.2.3
+Version: 0.2.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
+Project-URL: Documentation, https://reference.langchain.com/python/deepagents/
+Project-URL: Source, https://github.com/langchain-ai/deepagents
+Project-URL: Twitter, https://x.com/LangChainAI
+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
 License-File: LICENSE
@@ -10,12 +16,6 @@ Requires-Dist: langchain-anthropic<2.0.0,>=1.0.0
 Requires-Dist: langchain<2.0.0,>=1.0.2
 Requires-Dist: langchain-core<2.0.0,>=1.0.0
 Requires-Dist: wcmatch
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: build; extra == "dev"
-Requires-Dist: twine; extra == "dev"
-Requires-Dist: langchain-openai; extra == "dev"
 Dynamic: license-file
 
 # 🧠🤖Deep Agents

deepagents-0.2.5.dist-info/RECORD

@@ -0,0 +1,38 @@
+deepagents/__init__.py,sha256=9BVNn4lfF5N8l2KY8Ttxi82zO609I-fGqoSIF7DAxiU,342
+deepagents/graph.py,sha256=pwRKF9EsmBtc2LabAcqted92kIhG5b4SaEfACT2G4Ps,6094
+deepagents/backends/__init__.py,sha256=BOKu2cQ1OdMyO_l2rLqZQiXppYFmQbx7OIQb7WYwvZc,457
+deepagents/backends/composite.py,sha256=0jvuo2YBlr3LT3N10uE0p1-vVSCdkzK0uLciPRcUg8o,8431
+deepagents/backends/filesystem.py,sha256=SsVDx__j_AARIwRzaDuokbxbkquJ_Lw3Qi7dLWaqRUs,18674
+deepagents/backends/protocol.py,sha256=wmXk24BBN1vo3ALYTIZmCi5fjxNZeH8y06v1OXc5ABU,4555
+deepagents/backends/state.py,sha256=ST_tUExPxArJaA3U8vc1dyzxuYl2BQH-HU7P0eu_Ty8,6518
+deepagents/backends/store.py,sha256=HWGZ0euXp9ww4HvWYg1S-tEH17cuFy3F1lg3DiGN6CY,13232
+deepagents/backends/utils.py,sha256=Iyk2jW-gfoLvMnz-W_2FRCoJW_j3r1zoumU9iww-jd0,13973
+deepagents/middleware/__init__.py,sha256=x7UHqGcrKlhzORNdChPvnUwa_PIJCbFUHY6zTKVfloI,418
+deepagents/middleware/filesystem.py,sha256=7O2GUeGPQBslNBU1Gdser-tkL2DO_f8nZ9yZsGC3INs,28294
+deepagents/middleware/patch_tool_calls.py,sha256=PdNhxPaQqwnFkhEAZEE2kEzadTNAOO3_iJRA30WqpGE,1981
+deepagents/middleware/resumable_shell.py,sha256=KjhafjKu28Nf_8pDmSk_aWRK7pgkXZoubvWQljIEv3w,3382
+deepagents/middleware/subagents.py,sha256=dI9w_TXKb4I6-InHua993sICTQ4fw5GapgNkHc-q50I,23474
+deepagents-0.2.5.dist-info/licenses/LICENSE,sha256=c__BaxUCK69leo2yEKynf8lWndu8iwYwge1CbyqAe-E,1071
+deepagents-cli/README.md,sha256=LQksI_Z2qG3IMbIZ7ZRBQlWTufPZmIevGt7uya_HObg,49
+deepagents-cli/deepagents_cli/README.md,sha256=ajP946mBaKQRn_k3vViWfQn8v1BKiaw58gqb0xKmp4o,7413
+deepagents-cli/deepagents_cli/__init__.py,sha256=2W9tHzQianR_Q0ku9hc_ZI3kUYsilXQ6I_kUnpg9bzg,108
+deepagents-cli/deepagents_cli/__main__.py,sha256=J9-RNZv_zxw4SyjWRI_N7k7m8G4--vclD8vKxYIiXPQ,128
+deepagents-cli/deepagents_cli/agent.py,sha256=8GFi9XtfedYTL0J-f72ARb_glklIIFCyzI_9buAg3h4,11066
+deepagents-cli/deepagents_cli/agent_memory.py,sha256=Ma4P8sFpZ84ytb8GtqRcTv9Uy5E15oXqJzuBV9vuKmU,9147
+deepagents-cli/deepagents_cli/commands.py,sha256=rHsHij1xGs13N_m46YcBP2M2_MRGqRbSlnWaZaMnoco,2606
+deepagents-cli/deepagents_cli/config.py,sha256=gcYPDPltyhgMIiTNXQOaoKGqsAc-izNGPOlAqf_o7I0,4403
+deepagents-cli/deepagents_cli/default_agent_prompt.md,sha256=Pi9SvgOAa74qhgDUMexm2-S_OfUO_CTic3zdbUnuB4s,4964
+deepagents-cli/deepagents_cli/execution.py,sha256=2VqjnrT_LQn0b7eLqIIPW6oB4GeLFSR1w2X_3kjU4Lg,26498
+deepagents-cli/deepagents_cli/file_ops.py,sha256=LQ7NTXPWLwePbiTBDA-22_VHxEGil7NpBltHZx1C7r4,12362
+deepagents-cli/deepagents_cli/input.py,sha256=KXv9Kq13V1fK5bSRLfJxheYn8FH6_xc_l4fpcQlwqNc,10177
+deepagents-cli/deepagents_cli/main.py,sha256=cIyLfAU-eJrAf2i7aCEElVTO7xXPXW8jsje4REACfcg,7142
+deepagents-cli/deepagents_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deepagents-cli/deepagents_cli/token_utils.py,sha256=tEeghLW2-vsitc-ba9cklKYnjLgRpvK7rK7PRiUu8jA,2439
+deepagents-cli/deepagents_cli/tools.py,sha256=Av92Luq-vGgUr25DqErGi7aI6y6DdFSXLigffhNLxYk,4287
+deepagents-cli/deepagents_cli/ui.py,sha256=d5hMHuTYerAINehGHohTI0ln4u9vojPvK1fN4OrqEEI,18667
+deepagents-cli/tests/test_file_ops.py,sha256=xtu1UCmVf6gPadK0H33CtscCon8GAChi5oCboZfq-hg,3008
+deepagents-cli/tests/test_placeholder.py,sha256=awIMcOR8rWGq0p_kljsIkZKinVdDlyx3MqDMQgPSi6U,101
+deepagents-0.2.5.dist-info/METADATA,sha256=PiLwTOCG0BRgMteCvhAf4JhOOYxZW3EPq5Qb0_95fec,18828
+deepagents-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+deepagents-0.2.5.dist-info/top_level.txt,sha256=7lDw_vmqmbQPyEVg2wcsIMEM9rjFC8i4pDXlksJ7vao,26
+deepagents-0.2.5.dist-info/RECORD,,

deepagents-0.2.5.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+deepagents
+deepagents-cli

deepagents-cli/README.md

@@ -0,0 +1,3 @@
+# deepagents cli
+
+This is the CLI for deepagents

deepagents-cli/deepagents_cli/README.md

@@ -0,0 +1,196 @@
+# DeepAgents CLI
+
+Interactive command-line interface for DeepAgents - an AI coding assistant with file operations, web search, and shell command execution.
+
+## Architecture
+
+The CLI is organized into focused modules:
+
+```
+cli/
+├── __init__.py      # Package exports
+├── __main__.py      # Entry point for `python -m deepagents.cli`
+├── main.py          # CLI loop, argument parsing, main orchestration
+├── config.py        # Configuration, constants, colors, model creation
+├── tools.py         # Custom tools (http_request, web_search)
+├── ui.py            # Display logic, TokenTracker, help screens
+├── input.py         # Input handling, completers, prompt session
+├── commands.py      # Slash command and bash command handlers
+├── execution.py     # Task execution, streaming, HITL approval
+└── agent.py         # Agent creation, management, listing, reset
+```
+
+## Module Responsibilities
+
+### `main.py` - Entry Point & Main Loop
+- **Purpose**: CLI entry point, argument parsing, main interactive loop
+- **Key Functions**:
+  - `cli_main()` - Console script entry point (called when you run `deepagents`)
+  - `main()` - Async main function that orchestrates agent creation and CLI
+  - `simple_cli()` - Main interactive loop handling user input
+  - `parse_args()` - Command-line argument parsing
+  - `check_cli_dependencies()` - Validates required packages are installed
+
+### `config.py` - Configuration & Constants
+- **Purpose**: Centralized configuration, constants, and model creation
+- **Key Exports**:
+  - `COLORS` - Color scheme for terminal output
+  - `DEEP_AGENTS_ASCII` - ASCII art banner
+  - `COMMANDS` - Available slash commands
+  - `console` - Rich Console instance
+  - `create_model()` - Creates OpenAI or Anthropic model based on API keys
+  - `get_default_coding_instructions()` - Loads default agent prompt
+
+### `tools.py` - Custom Agent Tools
+- **Purpose**: Additional tools for the agent beyond built-in filesystem operations
+- **Tools**:
+  - `http_request()` - Make HTTP requests to APIs
+  - `web_search()` - Search the web using Tavily API
+  - `tavily_client` - Initialized Tavily client (if API key available)
+
+### `ui.py` - Display & Rendering
+- **Purpose**: All UI rendering and display logic
+- **Key Components**:
+  - `TokenTracker` - Track and display token usage across the session
+  - `render_todo_list()` - Render todo list with checkboxes
+  - `show_interactive_help()` - Display available commands during session
+  - `show_help()` - Full help screen
+  - `format_tool_message_content()` - Format tool messages for display
+  - `truncate_value()` - Truncate long values for readable display
+
+### `input.py` - Input Handling
+- **Purpose**: User input, completers, and prompt session configuration
+- **Key Components**:
+  - `FilePathCompleter` - Autocomplete for `@file` mentions
+  - `CommandCompleter` - Autocomplete for `/commands`
+  - `BashCompleter` - Autocomplete for `!bash` commands
+  - `parse_file_mentions()` - Extract `@file` mentions and inject content
+  - `create_prompt_session()` - Configure prompt_toolkit session with:
+    - Multi-line input (Alt+Enter for newlines, Enter to submit)
+    - Command history
+    - File/command autocomplete
+    - External editor support (Ctrl+E)
+
+### `commands.py` - Command Handlers
+- **Purpose**: Handle slash commands (`/help`, `/clear`, etc.) and bash execution
+- **Key Functions**:
+  - `handle_command()` - Route and execute slash commands
+  - `execute_bash_command()` - Execute bash commands prefixed with `!`
+
+### `execution.py` - Task Execution & Streaming
+- **Purpose**: Core execution logic, streaming responses, HITL (Human-in-the-Loop)
+- **Key Functions**:
+  - `execute_task()` - Main execution function that:
+    - Parses file mentions
+    - Streams agent responses
+    - Displays tool calls with icons
+    - Renders todo list updates
+    - Tracks token usage
+    - Handles Ctrl+C interruptions
+  - `prompt_for_shell_approval()` - Interactive shell command approval with arrow keys
+- **Features**:
+  - Dual-stream mode (messages + updates) for HITL support
+  - Real-time todo list rendering
+  - Spinner with status updates
+  - Token tracking integration
+
+### `agent.py` - Agent Management
+- **Purpose**: Agent creation, configuration, and management commands
+- **Key Functions**:
+  - `create_agent_with_config()` - Create agent with:
+    - Filesystem backends (working directory + agent directory)
+    - Long-term memory middleware
+    - Shell execution with HITL approval
+    - Custom system prompt
+  - `list_agents()` - List all agents in `~/.deepagents/`
+  - `reset_agent()` - Reset agent to default or copy from another agent
+
+## Data Flow
+
+```
+User Input
+    ↓
+main.py (simple_cli)
+    ↓
+input.py (parse_file_mentions, completers)
+    ↓
+execution.py (execute_task)
+    ↓
+agent.py (agent created with tools from tools.py)
+    ↓
+Stream responses → ui.py (render todos, display tool calls)
+                 → execution.py (HITL approval if needed)
+    ↓
+Display output via ui.py (TokenTracker, console)
+```
+
+## Key Features
+
+### File Context Injection
+Type `@filename` and press Tab to autocomplete and inject file content into your prompt.
+
+### Interactive Commands
+- `/help` - Show help
+- `/clear` - Clear screen and reset conversation
+- `/tokens` - Show token usage
+- `/quit` or `/exit` - Exit the CLI
+
+### Bash Commands
+Type `!command` to execute bash commands directly (e.g., `!ls`, `!git status`)
+
+### Todo List Tracking
+The agent can create and update a visual todo list for multi-step tasks.
+
+### File Operation Summaries & Diff Viewer
+- File reads now show a concise summary with the number of lines streamed (e.g., `⏺ Read(example.py)` followed by `⎿  Read 44 lines (lines 1-44)`).
+- Writes and edits capture before/after snapshots, reporting lines added or removed plus bytes written.
+- A Rich-powered unified diff renders in-line with syntax highlighting so you can review every proposed change before confirming.
+- Diff output truncates gracefully for very large edits while still surfacing a summary.
+- When Human-in-the-Loop approval is required, the proposed diff is shown *before* you choose Approve/Reject.
+
+### Human-in-the-Loop Shell Approval
+Shell commands require user approval with an interactive arrow-key menu.
+
+### Multi-line Input
+- **Enter** - Submit (or accept completion if menu is open)
+- **Alt+Enter** - Insert newline (Option+Enter on Mac, or ESC then Enter)
+- **Ctrl+E** - Open in external editor (nano by default)
+
+## Agent Storage
+
+Each agent stores its state in `~/.deepagents/AGENT_NAME/`:
+- `agent.md` - Agent's custom instructions (long-term memory)
+- `memories/` - Additional context files
+- `history` - Command history
+
+## Development
+
+To modify the CLI:
+
+1. **UI changes** → Edit `ui.py` or `input.py`
+2. **Add new tools** → Edit `tools.py`
+3. **Change execution flow** → Edit `execution.py`
+4. **Add commands** → Edit `commands.py`
+5. **Agent configuration** → Edit `agent.py`
+6. **Constants/colors** → Edit `config.py`
+
+## Running During Development
+
+```bash
+# From project root
+uv run python -m deepagents.cli
+
+# Or install in editable mode
+uv pip install -e .
+deepagents
+```
+
+## Entry Point
+
+The CLI is registered in `pyproject.toml` as:
+```toml
+[project.scripts]
+deepagents = "deepagents.cli:cli_main"
+```
+
+This means when users install the package, they can run `deepagents` directly.

deepagents-cli/deepagents_cli/__init__.py

@@ -0,0 +1,5 @@
+"""DeepAgents CLI - Interactive AI coding assistant."""
+
+from .main import cli_main
+
+__all__ = ["cli_main"]

deepagents-cli/deepagents_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running the CLI as: python -m deepagents.cli"""
+
+from .main import cli_main
+
+if __name__ == "__main__":
+    cli_main()