dex-agents-deepagents-cli 0.6.0__py3-none-any.whl

dex_agents_deepagents_cli/workspace_backend.py

@@ -0,0 +1,382 @@
+# Copyright (c) 2026 Super Durable, Inc.
+#
+# Licensed under the Sustainable Use License 1.0.
+# You may not use this file except in compliance with the License.
+# See the LICENSE file in the repository root.
+#
+# SPDX-License-Identifier: LicenseRef-Sustainable-Use-1.0
+
+"""The Deep Agents backend of the command: real files in the workspace and its shell."""
+
+from __future__ import annotations
+
+import contextlib
+import dataclasses
+import hashlib
+import logging
+import os
+import shutil
+import stat
+import time
+from collections.abc import Iterator
+from contextvars import ContextVar
+from datetime import timedelta
+from pathlib import Path
+
+from deepagents.backends import CompositeBackend, FilesystemBackend, LocalShellBackend
+from deepagents.backends.protocol import (
+    DEFAULT_GREP_TIMEOUT,
+    BackendProtocol,
+    GlobResult,
+    GrepResult,
+    LsResult,
+)
+from deepagents.backends.utils import compile_grep_include_glob
+
+#: The prefixes Deep Agents' ``FilesystemMiddleware`` writes its own files under.
+DEEP_AGENTS_ARTIFACT_PREFIXES = ("/large_tool_results/", "/conversation_history/")
+
+#: How long a session's artifacts stay after their last change.
+SESSION_ARTIFACTS_RETENTION = timedelta(days=30)
+
+_LOGGER = logging.getLogger(__name__)
+
+_RUNNING_SESSION_ID: ContextVar[str | None] = ContextVar(
+    "dex_agents_deepagents_running_session_id", default=None
+)
+
+# Search results keyed by path, each with its matching (line number, text) pairs.
+_SearchResults = dict[str, list[tuple[int, str]]]
+
+
+class WorkspaceShellBackend(LocalShellBackend):
+    """A ``LocalShellBackend`` on the host's paths whose file tools stay in the workspace.
+
+    File tools take absolute host paths, as Deep Agents' local mode does, so
+    a file tool and ``execute`` name a file the same way. A path that
+    resolves outside the workspace, through ``..`` or a symbolic link, fails
+    the file operation with an error the model sees. ``ls``, ``glob``, and
+    ``grep`` leave out every entry whose real path is outside the workspace,
+    and ``grep`` never opens such a file.
+
+    This is a guardrail against mistaken paths, not a sandbox. ``execute``
+    runs ``/bin/sh`` in the workspace with the user's permissions and can
+    reach any path. A link swapped during a call and a hard link to an
+    outside file are not detected.
+    """
+
+    def __init__(self, workspace: Path) -> None:
+        """Root the backend at the workspace.
+
+        Args:
+            workspace: The absolute workspace directory.
+
+        Raises:
+            RuntimeError: If the installed deepagents lacks the method the
+                confinement overrides.
+        """
+        if not callable(getattr(LocalShellBackend, "_resolve_path", None)):
+            # The confinement overrides this private method; the dependency range pins it.
+            raise RuntimeError(
+                "this deepagents release has no FilesystemBackend._resolve_path; install the "
+                "version range dex-agents-deepagents-cli declares"
+            )
+        super().__init__(root_dir=workspace, virtual_mode=False, inherit_env=True)
+        self._workspace_real_path = Path(os.path.realpath(workspace))
+
+    def ls(self, path: str) -> LsResult:
+        """List a directory, without the entries whose real path leaves the workspace."""
+        result = super().ls(path)
+        if result.entries is None:
+            return result
+        entries = [entry for entry in result.entries if self._is_inside(entry["path"])]
+        return dataclasses.replace(result, entries=entries)
+
+    def glob(self, pattern: str, path: str | None = None) -> GlobResult:
+        """Find files, without the matches whose real path leaves the workspace."""
+        result = super().glob(pattern, path)
+        if result.matches is None:
+            return result
+        matches = [match for match in result.matches if self._is_inside(match["path"])]
+        return dataclasses.replace(result, matches=matches)
+
+    def grep(
+        self,
+        pattern: str,
+        path: str | None = None,
+        glob: str | None = None,
+        *,
+        max_count: int | None = None,
+        context_lines: int = 0,
+    ) -> GrepResult:
+        """Search files, without the matches in files whose real path leaves the workspace."""
+        result = super().grep(pattern, path, glob, max_count=max_count, context_lines=context_lines)
+        if result.matches is None:
+            return result
+        matches = [match for match in result.matches if self._is_inside(match["path"])]
+        return dataclasses.replace(result, matches=matches)
+
+    def _python_search(
+        self,
+        pattern: str,
+        base_full: Path,
+        include_glob: str | None,
+        *,
+        max_count: int | None = None,
+        timeout: int = DEFAULT_GREP_TIMEOUT,
+    ) -> tuple[_SearchResults, bool, str | None]:
+        # Deep Agents' fallback opens every file it walks; this one checks each real path first.
+        deadline = time.monotonic() + timeout
+        matches_glob = compile_grep_include_glob(include_glob) if include_glob else None
+        root = base_full if base_full.is_dir() else base_full.parent
+        candidates = (
+            [base_full]
+            if base_full.is_file()
+            else (
+                Path(directory) / name
+                for directory, _, names in os.walk(root, followlinks=False)
+                for name in names
+            )
+        )
+        results: _SearchResults = {}
+        unreadable: list[str] = []
+        total = 0
+        for candidate in candidates:
+            if time.monotonic() > deadline:
+                return results, True, None
+            if matches_glob is not None and not matches_glob(
+                candidate.relative_to(root).as_posix()
+            ):
+                continue
+            if not self._is_inside(str(candidate)) or not _is_small_file(
+                candidate, self.max_file_size_bytes
+            ):
+                continue
+            try:
+                with candidate.open(encoding="utf-8", errors="strict") as handle:
+                    for line_number, line in enumerate(handle, 1):
+                        if pattern not in line:
+                            continue
+                        if max_count is not None and total >= max_count:
+                            return results, True, None
+                        results.setdefault(str(candidate), []).append(
+                            (line_number, line.rstrip("\n"))
+                        )
+                        total += 1
+            except UnicodeDecodeError:
+                # Binary files are skipped, as ripgrep does.
+                continue
+            except OSError as error:
+                unreadable.append(f"- {candidate}: {type(error).__name__}: {error.strerror}")
+        if not unreadable:
+            return results, False, None
+        return (
+            results,
+            False,
+            "One or more files could not be fully searched:\n" + "\n".join(unreadable),
+        )
+
+    def _resolve_path(self, key: str) -> Path:
+        resolved = super()._resolve_path(key)
+        if not self._is_inside(str(resolved)):
+            # An OSError, so each file operation reports it as its own error result.
+            raise PermissionError(
+                f"{key} is outside the workspace {self._workspace_real_path}; file tools "
+                "may only use paths inside it"
+            )
+        return resolved
+
+    def _is_inside(self, path: str) -> bool:
+        # realpath also follows a dangling link to the target a write would create.
+        real_path = Path(os.path.realpath(self.cwd / path))
+        return real_path.is_relative_to(self._workspace_real_path)
+
+
+class SessionArtifactsBackend(FilesystemBackend):
+    """A virtual ``FilesystemBackend`` whose root is one private directory per session.
+
+    Deep Agents names a large tool result after its tool call ID, which two
+    sessions may share. Each session therefore gets its own directory,
+    ``<artifacts>/<SHA-256 of the session ID>/<name>``. The name is stable,
+    so a Worker that restarts on the same machine finds the files. Every
+    file operation first checks each directory of that path: the user owns
+    it, it is no symbolic link, and its mode becomes 0700 when it is looser.
+    A failed check, or an operation outside a running model call or tool
+    Step, returns the operation's error result.
+    """
+
+    def __init__(self, artifacts_directory: Path, name: str) -> None:
+        """Keep the per-user directory and the name of this kind of file.
+
+        Args:
+            artifacts_directory: The private per-user directory, such as
+                ``default_artifacts_directory()``.
+            name: The subdirectory of each session, such as ``large_tool_results``.
+        """
+        self._artifacts_directory = artifacts_directory
+        self._name = name
+        super().__init__(root_dir=artifacts_directory, virtual_mode=True)
+
+    @property
+    def cwd(self) -> Path:
+        """Return the running session's checked directory.
+
+        Raises:
+            PermissionError: Outside a running session, or when a directory of
+                the path fails its check. Every file operation reports it as an error.
+        """
+        session_id = _RUNNING_SESSION_ID.get()
+        if session_id is None:
+            raise PermissionError("Deep Agents' own files are available only while a session runs")
+        artifacts = ensure_artifacts_directory(self._artifacts_directory)
+        session_directory = _private_directory(
+            artifacts / hashlib.sha256(session_id.encode()).hexdigest()
+        )
+        # The virtual root check compares resolved paths.
+        return _private_directory(session_directory / self._name).resolve()
+
+    @cwd.setter
+    def cwd(self, root_dir: Path) -> None:
+        # FilesystemBackend's constructor assigns its root; each session's root replaces it.
+        return None
+
+
+@contextlib.contextmanager
+def bind_artifacts_session(session_id: str) -> Iterator[None]:
+    """Make Deep Agents' own files those of one session while the block runs.
+
+    Args:
+        session_id: The session ID, which is the Flow ID.
+    """
+    token = _RUNNING_SESSION_ID.set(session_id)
+    try:
+        yield
+    finally:
+        _RUNNING_SESSION_ID.reset(token)
+
+
+def build_workspace_backend(
+    workspace: Path, artifacts_directory: Path | None = None
+) -> CompositeBackend:
+    """Build the command's backend: the workspace, with Deep Agents' own files kept apart.
+
+    Deep Agents writes large tool results and long user messages under
+    ``/large_tool_results/`` and ``/conversation_history/``. Those prefixes go
+    to the running session's private directory, so they never land at the
+    file system root, in the workspace, or in another session.
+
+    Args:
+        workspace: The absolute workspace directory.
+        artifacts_directory: The per-user directory of Deep Agents' own
+            files; ``None`` uses ``default_artifacts_directory()``.
+
+    Returns:
+        The backend for ``create_deep_agent``.
+    """
+    artifacts = artifacts_directory or default_artifacts_directory()
+    routes: dict[str, BackendProtocol] = {
+        prefix: SessionArtifactsBackend(artifacts, prefix.strip("/"))
+        for prefix in DEEP_AGENTS_ARTIFACT_PREFIXES
+    }
+    return CompositeBackend(default=WorkspaceShellBackend(workspace), routes=routes)
+
+
+def default_artifacts_directory() -> Path:
+    """Return the per-user directory of Deep Agents' own files, without creating it.
+
+    Returns:
+        ``~/.dex/agents/deepagents-artifacts``.
+    """
+    return Path.home() / ".dex" / "agents" / "deepagents-artifacts"
+
+
+def ensure_artifacts_directory(artifacts_directory: Path) -> Path:
+    """Create the per-user artifacts directory and check it and its two parents.
+
+    The parents, such as ``~/.dex`` and ``~/.dex/agents``, keep their mode,
+    but neither may be a symbolic link that another user owns.
+
+    Args:
+        artifacts_directory: The per-user directory.
+
+    Returns:
+        The directory, owned by the user, mode 0700.
+
+    Raises:
+        PermissionError: If a parent is another user's link, or the directory
+            is a link or another user's.
+    """
+    for parent in (artifacts_directory.parent.parent, artifacts_directory.parent):
+        if parent.is_symlink() and parent.lstat().st_uid != os.getuid():
+            raise PermissionError(f"{parent} is a link that another user owns")
+    artifacts_directory.parent.mkdir(parents=True, exist_ok=True)
+    return _private_directory(artifacts_directory)
+
+
+def remove_stale_session_artifacts(
+    artifacts_directory: Path, retention: timedelta = SESSION_ARTIFACTS_RETENTION
+) -> list[Path]:
+    """Delete the session directories whose files nothing changed within the retention.
+
+    The command calls it once when it starts. It never follows a link, and
+    a directory it cannot read or delete stays and is logged.
+
+    Args:
+        artifacts_directory: The per-user directory.
+        retention: How long after its last change a session's files stay.
+
+    Returns:
+        The deleted session directories.
+    """
+    if not artifacts_directory.is_dir() or artifacts_directory.is_symlink():
+        return []
+    cutoff = time.time() - retention.total_seconds()
+    removed: list[Path] = []
+    try:
+        session_directories = list(artifacts_directory.iterdir())
+    except OSError as error:
+        _LOGGER.warning("cannot list session artifacts in %s: %s", artifacts_directory, error)
+        return removed
+    for session_directory in session_directories:
+        try:
+            if not stat.S_ISDIR(session_directory.lstat().st_mode):
+                continue
+            if _latest_change(session_directory) >= cutoff:
+                continue
+            shutil.rmtree(session_directory)
+        except OSError as error:
+            _LOGGER.warning(
+                "cannot remove stale session artifacts %s: %s", session_directory, error
+            )
+            continue
+        _LOGGER.info("removed stale session artifacts %s", session_directory)
+        removed.append(session_directory)
+    return removed
+
+
+def _latest_change(directory: Path) -> float:
+    latest = directory.lstat().st_mtime
+    for parent, directory_names, file_names in os.walk(directory, followlinks=False):
+        for name in (*directory_names, *file_names):
+            latest = max(latest, (Path(parent) / name).lstat().st_mtime)
+    return latest
+
+
+def _private_directory(directory: Path) -> Path:
+    directory.mkdir(mode=0o700, exist_ok=True)
+    status = directory.lstat()
+    if stat.S_ISLNK(status.st_mode) or not stat.S_ISDIR(status.st_mode):
+        raise PermissionError(f"{directory} is not a directory")
+    if status.st_uid != os.getuid():
+        raise PermissionError(f"{directory} belongs to another user")
+    if stat.S_IMODE(status.st_mode) & 0o077:
+        directory.chmod(0o700)
+    return directory
+
+
+def _is_small_file(path: Path, max_bytes: int) -> bool:
+    try:
+        status = path.stat()
+    except OSError:
+        return False
+    return stat.S_ISREG(status.st_mode) and status.st_size <= max_bytes

dex_agents_deepagents_cli-0.6.0.dist-info/METADATA

@@ -0,0 +1,199 @@
+Metadata-Version: 2.4
+Name: dex-agents-deepagents-cli
+Version: 0.6.0
+Summary: The dex-agents-deepagents command: a durable Deep Agents agent in your terminal
+Author: Super Durable
+License-Expression: LicenseRef-Sustainable-Use-1.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Dist: deepagents>=0.7.32,<0.8
+Requires-Dist: dex-agents==0.6.0
+Requires-Dist: dex-agents-cli-core==0.6.0
+Requires-Dist: dex-agents-langgraph==0.6.0
+Requires-Dist: dex-python-sdk==1.45.0
+Requires-Dist: langchain>=1.4.7,<2
+Requires-Dist: langchain-core>=1.7.3,<1.8
+Requires-Dist: langchain-openai>=1.0,<2
+Requires-Dist: langgraph>=1.2.19,<1.3
+Requires-Python: >=3.11
+Project-URL: Homepage, https://github.com/superdurable/dex/tree/main/agents/cli/python/deepagents
+Project-URL: Repository, https://github.com/superdurable/dex
+Project-URL: Changelog, https://github.com/superdurable/dex/blob/main/agents/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# dex-agents-deepagents-cli
+
+`dex-agents-deepagents-cli` provides the `dex-agents-deepagents` command. It
+runs a [Deep Agents](https://github.com/langchain-ai/deepagents) agent as a
+durable Dex agent session and chats with it in your terminal. The shared
+CLI core, [`dex-agents-cli-core`](../core/README.md), starts or reuses
+`dexcli dev`, connects the connectors MCP server, and runs the Worker. This
+package only builds the agent with `create_deep_agent` and runs it on the
+[LangGraph adapter](../../../python/langgraph/README.md).
+
+## Running it
+
+The command needs Python 3.11 or later and a key for the model's provider.
+The default model is OpenAI's, so set `OPENAI_API_KEY`:
+
+```bash
+export OPENAI_API_KEY=sk-...
+uvx --from dex-agents-deepagents-cli dex-agents-deepagents
+```
+
+The first run asks the `init` questions and writes
+`~/.dex/agents/deepagents.yaml`. Then type a message at the `>` prompt.
+Approve or reject tool calls with `y` or `n`, and press Ctrl-D to exit. The
+session stays in Dex, and the command prints the `--resume` line that
+continues it. See the [CLI core README](../core/README.md#running-a-command)
+for every subcommand and option, and [`agents/cli`](../../README.md) for the
+configuration file.
+
+The command never prints or stores provider keys. The chat model reads its
+key from the provider's standard environment variable.
+
+## Configuration
+
+`model` is a LangChain `provider:model` ID, as `init_chat_model` takes it. It
+defaults to `openai:gpt-5.2`; set `model` in the file or pass `--model` to
+change it. An `openai:` model uses the Responses API, as Deep Agents does.
+
+| Provider | Model example | Environment |
+| --- | --- | --- |
+| OpenAI | `openai:gpt-5.2` | `OPENAI_API_KEY`, optional `OPENAI_BASE_URL` |
+| Anthropic | `anthropic:claude-opus-5-5` | `ANTHROPIC_API_KEY` |
+| Google | `google_genai:gemini-2.5-flash` | `GOOGLE_API_KEY` |
+
+Other providers need their LangChain integration package, such as
+`uvx --from dex-agents-deepagents-cli --with langchain-mistralai dex-agents-deepagents`.
+
+`system_prompt` replaces the default instructions. Session settings may
+change the model and the instructions from the next turn on. The
+`deepagents` section has no options yet, and any key in it is a configuration
+error.
+
+## Deep Agents' tools in Dex
+
+The agent keeps Deep Agents' own tools and behavior. The CLI core adds the
+connector, web fetch, and browser tools on top. The agent runs on the
+LangGraph adapter, so every model call is a `RunModel` Step and every tool
+call runs in its own tool Step, after approval when its policy asks for it.
+
+| Deep Agents tool | In this command |
+| --- | --- |
+| `ls`, `read_file`, `glob`, `grep` | Reads of the real workspace files. They run at once. |
+| `write_file`, `edit_file`, `delete` | Writes of the real workspace files. They run at once unless `approval.always` names the tool. |
+| `execute` | Runs a command with `/bin/sh` in the workspace. It runs at once unless `approval.always` names it; `local_tools.shell.allow` has no effect. |
+| `task` | Runs a subagent inside the call's tool Step. It runs at once unless `approval.always` names any Deep Agents tool, because the subagent may call it without its own approval. |
+| `write_todos` | Updates the todo list in the agent's state. It runs at once. |
+
+- Deep Agents asks for no approval unless `interrupt_on` names a tool, and
+  this command follows it: `approval.always` plays the role of
+  `interrupt_on`. Connector writes always wait for approval.
+- The file tools use Deep Agents' `LocalShellBackend` on the host's paths,
+  rooted at the workspace, so a file tool and `execute` name a file the same
+  way. Paths are absolute. A path that resolves outside the workspace fails
+  with an error the model sees, and `ls`, `glob`, and `grep` leave out
+  entries whose real path is outside it, such as a link to a file elsewhere;
+  `grep` never opens such a file.
+- That check is a guardrail against mistaken paths, not a sandbox.
+  `execute` runs any command with your permissions, without approval by
+  default. A link that changes during a call, or a hard link in the
+  workspace to a file elsewhere, is not detected. Use OS-level isolation,
+  such as a container, when the agent must not reach other files.
+- `local_tools.files` and `local_tools.shell.enabled` switch the tools on and
+  off per turn. `task` needs both, because a subagent uses both.
+- Each tool Step attempt runs Deep Agents' tool middleware around the tool,
+  such as `FilesystemMiddleware`'s eviction of a large result to a file. A
+  retried attempt runs it again. The
+  session Flow sets the adapter's `should_defer_tool_calls_before_middleware`
+  for that. Deep Agents writes evicted results and long user messages under
+  the paths `/large_tool_results/` and `/conversation_history/`, which its
+  file tools read. Each session keeps them in its own directory,
+  `~/.dex/agents/deepagents-artifacts/<SHA-256 of the session ID>/`, so two
+  sessions never see each other's files and a restarted Worker on the same
+  machine finds them. Before each file operation the command checks every
+  directory from `deepagents-artifacts` down: you own it, it is no link, and
+  a looser mode becomes 0700. `~/.dex` and `~/.dex/agents` keep their mode
+  but must not be another user's link. A failed check is an error result of
+  that tool call.
+- When the command starts, it deletes the artifacts of every session whose
+  files changed more than 30 days ago. It never follows a link, and it logs
+  each directory it removes or cannot remove. A session resumed after that
+  can no longer read its earlier large results.
+- `edit_file`, `execute`, and `task` calls are never retried, so a Worker that
+  dies during one records `outcome_unknown`. `write_file` and `delete` calls
+  may run again after a failure.
+- `write_todos` is LangChain's `TodoListMiddleware` tool. It returns a graph
+  `Command` that the adapter records and applies. Each turn starts from the
+  stored messages, so the todo list lasts for one turn; the plan stays in the
+  conversation.
+- `task` runs the subagent's model and tool calls inline, in one tool Step.
+  They have no Steps or approvals of their own, use the configuration file's
+  model even when session settings change it, and do not count in the
+  session's usage. Connector tools are not offered to a subagent.
+- A connector tool whose name a Deep Agents tool has gets the prefix
+  `connector_`, such as `connector_read_file`. The other connector tools keep
+  their names.
+- Every model call gets the turn's instructions, the workspace path, and the
+  turn's model through the adapter's `select_turn_chat_model`.
+- Deep Agents' summarization is turned off for now. It would make an extra
+  model call with the configuration file's model inside a `RunModel` Step, so
+  a model from the session settings would not reach it. The session does not
+  compact either: Dex compaction needs
+  the model's context window, which the configuration does not set. A long
+  session ends when its input no longer fits the model's context window;
+  start a new session then.
+
+## Images
+
+`/image <path>` attaches an image file to the next message. The command gives
+the LangChain adapter the media store of `media.store`, so the model sees the
+image, and images that tools return go to the same store. See
+[Images](../../README.md#images).
+
+## Development
+
+Develop with uv 0.12.2. The package resolves `dex-agents`, the LangGraph
+adapter, the CLI core, and the test support package from this repository by
+path. `ci.sh` installs the locked dependencies, checks that LangChain and
+LangGraph match the adapter's lock, checks lint and types, and runs the tests
+against a private `dexcli dev`:
+
+```bash
+cd agents/cli/python/deepagents
+DEXCLI=/path/to/dexcli ./ci.sh
+```
+
+The tests run the command in a pseudo-terminal with a private home. The chat
+model calls the scripted Responses API of
+[`dex-agents-cli-testing`](../testing) on 127.0.0.1; a refused proxy stops
+any other request, and no provider variable of the host reaches the command.
+A fake connectors MCP server serves a connector read and write. The tests
+cover a chat turn and `--resume`; `read_file`, `write_file`, and `edit_file` on
+real workspace files without approval; `execute` in the workspace; a path
+outside the workspace, which is refused; `write_file` waiting for approval
+when `approval.always` names it, and rejected file and connector writes that
+never run; a connector read and an approved connector write that runs once; a
+connector tool named `read_file`, which the model sees as
+`connector_connector_read_file` beside a connector tool named
+`connector_read_file`; `write_todos`; a `task` subagent that writes a
+workspace file inside one tool Step, and a `task` that waits for approval
+when `approval.always` names `read_file`; and a large `execute` result that
+lands in the session's own artifacts directory. Backend tests cover links to
+files outside the workspace, which `ls`, `glob`, and `grep` leave out with
+and without ripgrep, which the Python search never opens, and which reads and
+writes refuse; two sessions that write the same large-result path without
+seeing each other's file; a session directory that is a link, which is an
+error result; looser artifact directories, which become 0700; and the
+removal of a session's artifacts after 30 days, which never follows a link.
+They also cover the offered tools, which are Deep Agents' own and none of
+the CLI core's file and shell tools; switched-off file and shell tools, which
+are not offered; a model change and a `system_prompt` in the session
+settings, which reach the next model request; and a key in the `deepagents`
+section. The command also checks that its graph has no summarization, that
+its tool rules cover every tool of the graph, and that a model from the
+session settings reaches every model call.

dex_agents_deepagents_cli-0.6.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+dex_agents_deepagents_cli/__init__.py,sha256=ZVSn5vyc1EvFoAuD5LCWzEZ0BlvKPq5fizm1rsgHQJU,3303
+dex_agents_deepagents_cli/__main__.py,sha256=uSDfXwYWxHJwhAj7UCtHJBTQxnGXne8Y36zGIp7tvuM,439
+dex_agents_deepagents_cli/connector_tool_names.py,sha256=-yk6GznBfoep-tVOpkB4SCwP11LFdosUxacsMyP_92s,5727
+dex_agents_deepagents_cli/harness.py,sha256=QQVth1mZDVn_xgFoxegUgvLdSN0AFJRPePdDYY2S6Ic,17073
+dex_agents_deepagents_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dex_agents_deepagents_cli/workspace_backend.py,sha256=oLfXfAonzJTt7zsW7631WP9iAs1C9zkyUL64IwmrhzQ,15152
+dex_agents_deepagents_cli-0.6.0.dist-info/licenses/LICENSE,sha256=0AJCV4ky-vrSnT08IIdYpyiFPPoF2UrtKsBAvuvt1G4,4220
+dex_agents_deepagents_cli-0.6.0.dist-info/WHEEL,sha256=q9Wah2_CgP24mRNSlTyb0F8Yrbz55SzVl8eHLkZ_wvE,80
+dex_agents_deepagents_cli-0.6.0.dist-info/entry_points.txt,sha256=mfNobIu3HGTTaMsMjsFyvQpLzpZWev5Oi3_7AjgJS4U,73
+dex_agents_deepagents_cli-0.6.0.dist-info/METADATA,sha256=kwCBKYJsz3Y4MAU0qAq17QgLJcVdQKb24FzkktJiPwg,10950
+dex_agents_deepagents_cli-0.6.0.dist-info/RECORD,,

dex_agents_deepagents_cli-0.6.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.2
+Root-Is-Purelib: true
+Tag: py3-none-any

dex_agents_deepagents_cli-0.6.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+dex-agents-deepagents = dex_agents_deepagents_cli:run
+