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

dex_agents_deepagents_cli/__init__.py

@@ -0,0 +1,112 @@
+# 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 ``dex-agents-deepagents`` command: a Deep Agents agent in the terminal.
+
+It builds the agent session Flow from ``create_deep_agent`` with the Dex
+LangGraph adapter and runs it with the shared Dex Agents CLI core. See the
+package README.
+"""
+
+import dex_agents_cli_core  # noqa: F401  # first: it configures gRPC before anything imports it
+
+# isort: split
+
+import sys
+
+from dex_agents_cli_core import ConfigError, command_name, run_agent_cli
+from dex_agents_deepagents_cli.connector_tool_names import (
+    COLLIDING_CONNECTOR_TOOL_PREFIX,
+    PrefixedConnectorToolSource,
+)
+from dex_agents_deepagents_cli.harness import (
+    DEEP_AGENTS_TOOL_RULES,
+    DEEPAGENTS_CLI_FLOW_TYPE,
+    DEFAULT_DEEPAGENTS_MODEL,
+    DEFAULT_INSTRUCTIONS,
+    EXECUTE_TOOL_NAME,
+    TASK_TOOL_NAME,
+    WRITE_TODOS_TOOL_NAME,
+    DeepAgentsAgentRunner,
+    DeepAgentsHarness,
+    DeepAgentsToolRule,
+    LocalToolSwitchesMiddleware,
+    TurnChatModelSelector,
+    TurnInstructionsMiddleware,
+    build_deep_agent,
+    deep_agents_chat_model,
+    deep_agents_tool_sources,
+    validate_deepagents_section,
+)
+from dex_agents_deepagents_cli.workspace_backend import (
+    DEEP_AGENTS_ARTIFACT_PREFIXES,
+    SESSION_ARTIFACTS_RETENTION,
+    SessionArtifactsBackend,
+    WorkspaceShellBackend,
+    bind_artifacts_session,
+    build_workspace_backend,
+    default_artifacts_directory,
+    ensure_artifacts_directory,
+    remove_stale_session_artifacts,
+)
+
+__all__ = [
+    "COLLIDING_CONNECTOR_TOOL_PREFIX",
+    "DEEPAGENTS_CLI_FLOW_TYPE",
+    "DEEP_AGENTS_ARTIFACT_PREFIXES",
+    "DEEP_AGENTS_TOOL_RULES",
+    "DEFAULT_DEEPAGENTS_MODEL",
+    "DEFAULT_INSTRUCTIONS",
+    "EXECUTE_TOOL_NAME",
+    "SESSION_ARTIFACTS_RETENTION",
+    "TASK_TOOL_NAME",
+    "WRITE_TODOS_TOOL_NAME",
+    "DeepAgentsAgentRunner",
+    "DeepAgentsHarness",
+    "DeepAgentsToolRule",
+    "LocalToolSwitchesMiddleware",
+    "PrefixedConnectorToolSource",
+    "SessionArtifactsBackend",
+    "TurnChatModelSelector",
+    "TurnInstructionsMiddleware",
+    "WorkspaceShellBackend",
+    "bind_artifacts_session",
+    "build_deep_agent",
+    "build_workspace_backend",
+    "deep_agents_chat_model",
+    "deep_agents_tool_sources",
+    "default_artifacts_directory",
+    "ensure_artifacts_directory",
+    "main",
+    "remove_stale_session_artifacts",
+    "run",
+    "validate_deepagents_section",
+]
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run the command and return its exit code.
+
+    Args:
+        argv: The arguments without the program name; ``None`` reads ``sys.argv``.
+
+    Returns:
+        0 on success, 1 for a failure at run time, and 2 for a usage or
+        configuration error, such as a key in the ``deepagents`` section.
+    """
+    harness = DeepAgentsHarness()
+    try:
+        return run_agent_cli(harness, argv)
+    except ConfigError as error:
+        print(f"{command_name(harness)}: {error}", file=sys.stderr)
+        return 2
+
+
+def run() -> None:
+    """Run the command from its console script and exit with its code."""
+    raise SystemExit(main())

dex_agents_deepagents_cli/__main__.py

@@ -0,0 +1,14 @@
+# 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
+
+"""``python -m dex_agents_deepagents_cli`` runs the ``dex-agents-deepagents`` command."""
+
+from dex_agents_deepagents_cli import run
+
+if __name__ == "__main__":
+    run()

dex_agents_deepagents_cli/connector_tool_names.py

@@ -0,0 +1,138 @@
+# 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
+
+"""Connector tools next to Deep Agents' own: prefixed on a name collision, writes approved."""
+
+from __future__ import annotations
+
+import dataclasses
+from collections.abc import Collection, Sequence
+
+from dex_agents import (
+    AgentToolCall,
+    AgentTurnContext,
+    DeferredToolCall,
+    DeferredToolExecution,
+    DeferredToolOutcome,
+    ToolCallStepOptions,
+    ToolEffect,
+    ToolPolicy,
+    ToolTaskCancellation,
+    ToolTaskPoll,
+    ToolTaskPollOutcome,
+)
+from dex_agents.builtin_loop import SourceToolDefinition, ToolSource
+
+#: The prefix of a connector tool whose name a Deep Agents tool already uses.
+COLLIDING_CONNECTOR_TOOL_PREFIX = "connector_"
+
+
+class PrefixedConnectorToolSource:
+    """Offer a connectors tool source's tools beside Deep Agents' tools.
+
+    A connector tool keeps its name unless a Deep Agents tool has it; then
+    the model sees it as ``connector_<name>``, and ``approval.always`` names
+    it that way. When the source also lists that name, the prefix repeats
+    until the name is free, so every offered name is unique. The source
+    still runs the connector operation it listed. Every call that is not a
+    read waits for approval.
+    """
+
+    def __init__(self, source: ToolSource, reserved_tool_names: Collection[str]) -> None:
+        """Wrap one connectors tool source.
+
+        Args:
+            source: The CLI core's connectors tool source.
+            reserved_tool_names: The Deep Agents tool names. They are fixed, so
+                every Worker prefixes the same tools.
+        """
+        self._source = source
+        self._reserved_tool_names = frozenset(reserved_tool_names)
+
+    @property
+    def source_name(self) -> str:
+        """Return the wrapped source's name, so stored calls reach it on any Worker."""
+        return self._source.source_name
+
+    async def list_tools(self) -> Sequence[SourceToolDefinition]:
+        """Return the source's listing, each colliding name prefixed."""
+        return self._agent_visible_listing(await self._source.list_tools())
+
+    def cached_tools(self) -> Sequence[SourceToolDefinition]:
+        """Return the source's last listing, each colliding name prefixed."""
+        read_cache = getattr(self._source, "cached_tools", None)
+        cached: Sequence[SourceToolDefinition] = read_cache() if callable(read_cache) else ()
+        return self._agent_visible_listing(cached)
+
+    def deferred_tool_call(
+        self,
+        turn: AgentTurnContext,
+        *,
+        tool_call_id: str,
+        tool_name: str,
+        arguments: str,
+        listed_tool: SourceToolDefinition,
+    ) -> DeferredToolCall:
+        """Build the source's call under the agent's name, with approval for every write."""
+        built = self._source.deferred_tool_call(
+            turn,
+            tool_call_id=tool_call_id,
+            tool_name=tool_name,
+            arguments=arguments,
+            listed_tool=listed_tool,
+        )
+        if built.policy.effect is ToolEffect.READ or built.policy.is_approval_required:
+            return built
+        return dataclasses.replace(
+            built, policy=ToolPolicy(built.policy.effect, requires_approval=True)
+        )
+
+    async def execute_deferred_tool_call(self, call: DeferredToolExecution) -> DeferredToolOutcome:
+        """Run one call through the source, which reads the operation from its own reference."""
+        return await self._source.execute_deferred_tool_call(call)
+
+    async def poll_tool_task(self, poll: ToolTaskPoll) -> ToolTaskPollOutcome:
+        """Poll one of the source's tool tasks."""
+        return await self._source.poll_tool_task(poll)
+
+    async def cancel_tool_task(self, cancellation: ToolTaskCancellation) -> None:
+        """Cancel one of the source's abandoned tool tasks, when the source can."""
+        cancel = getattr(self._source, "cancel_tool_task", None)
+        if callable(cancel):
+            await cancel(cancellation)
+
+    def tool_call_step_options(self, tool_call: AgentToolCall) -> ToolCallStepOptions | None:
+        """Return the source's options for one call's tool Step, or ``None`` for the defaults."""
+        provide = getattr(self._source, "tool_call_step_options", None)
+        options: ToolCallStepOptions | None = provide(tool_call) if callable(provide) else None
+        return options
+
+    def _agent_visible_listing(
+        self, tools: Sequence[SourceToolDefinition]
+    ) -> list[SourceToolDefinition]:
+        # Names the source lists and Deep Agents' names stay taken; renamed tools avoid them all.
+        taken = set(self._reserved_tool_names)
+        taken.update(tool.name for tool in tools if tool.name not in self._reserved_tool_names)
+        visible: list[SourceToolDefinition] = []
+        for tool in tools:
+            if tool.name not in self._reserved_tool_names:
+                visible.append(tool)
+                continue
+            name = f"{COLLIDING_CONNECTOR_TOOL_PREFIX}{tool.name}"
+            while name in taken:
+                name = f"{COLLIDING_CONNECTOR_TOOL_PREFIX}{name}"
+            taken.add(name)
+            visible.append(_renamed(tool, name))
+        return visible
+
+
+def _renamed(tool: SourceToolDefinition, name: str) -> SourceToolDefinition:
+    if not dataclasses.is_dataclass(tool) or isinstance(tool, type):
+        raise TypeError(f"cannot rename the listed tool {tool.name}: it is not a dataclass")
+    renamed: SourceToolDefinition = dataclasses.replace(tool, name=name)
+    return renamed