pygent 0.1.12__tar.gz → 0.1.14__tar.gz

pygent-0.1.14/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: pygent
+Version: 0.1.14
+Summary: Pygent is a minimalist coding assistant that runs commands in a Docker container when available and falls back to local execution. See https://marianochaves.github.io/pygent for documentation and https://github.com/marianochaves/pygent for the source code.
+Author-email: Mariano Chaves <mchaves.software@gmail.com>
+Project-URL: Documentation, https://marianochaves.github.io/pygent
+Project-URL: Repository, https://github.com/marianochaves/pygent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.7.0
+Requires-Dist: openai>=1.0.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == "docs"
+Provides-Extra: docker
+Requires-Dist: docker>=7.0.0; extra == "docker"
+Provides-Extra: ui
+Requires-Dist: gradio; extra == "ui"
+Dynamic: license-file
+
+# Pygent
+
+Pygent is a coding assistant that executes each request inside an isolated Docker container whenever possible. If Docker is unavailable (for instance on some Windows setups) the commands are executed locally instead. Full documentation is available in the `docs/` directory and at [marianochaves.github.io/pygent](https://marianochaves.github.io/pygent/).
+
+## Features
+
+* Runs commands in ephemeral containers (default image `python:3.12-slim`).
+* Integrates with OpenAI-compatible models to orchestrate each step.
+* Persists the conversation history during the session.
+* Provides a small Python API for use in other projects.
+* Optional web interface via `pygent-ui`.
+* Register your own tools and customise the system prompt.
+
+## Installation
+
+Installing from source is recommended:
+
+```bash
+pip install -e .
+```
+
+Python ≥ 3.9 is required. The package now bundles the `openai` client for model access.
+To run commands in Docker containers also install `pygent[docker]`.
+
+## Configuration
+
+Behaviour can be adjusted via environment variables (see `docs/configuration.md` for a complete list):
+
+* `OPENAI_API_KEY` &ndash; key used to access the OpenAI API.
+  Set this to your API key or a key from any compatible provider.
+* `OPENAI_BASE_URL` &ndash; base URL for OpenAI-compatible APIs
+  (defaults to ``https://api.openai.com/v1``).
+* `PYGENT_MODEL` &ndash; model name used for requests (default `gpt-4.1-mini`).
+* `PYGENT_IMAGE` &ndash; Docker image to create the container (default `python:3.12-slim`).
+* `PYGENT_USE_DOCKER` &ndash; set to `0` to disable Docker and run locally.
+* `PYGENT_MAX_TASKS` &ndash; maximum number of concurrent delegated tasks (default `3`).
+
+## CLI usage
+
+After installing run:
+
+```bash
+pygent
+```
+
+Use `--docker` to run commands inside a container (requires
+`pygent[docker]`). Use `--no-docker` or set `PYGENT_USE_DOCKER=0`
+to force local execution.
+
+Type messages normally; use `/exit` to end the session. Each command is executed
+in the container and the result shown in the terminal.
+Interactive programs that expect input (e.g. running `python` without a script)
+are not supported and will exit immediately.
+For a minimal web interface run `pygent-ui` instead (requires `pygent[ui]`).
+
+
+## API usage
+
+You can also interact directly with the Python code:
+
+```python
+from pygent import Agent
+
+ag = Agent()
+ag.step("echo 'Hello World'")
+# ... more steps
+ag.runtime.cleanup()
+```
+
+See the [examples](https://github.com/marianochaves/pygent/tree/main/examples) folder for more complete scripts. Models can be swapped by
+passing an object implementing the ``Model`` interface when creating the
+``Agent``. The default uses an OpenAI-compatible API, but custom models are
+easy to plug in.
+
+### Using OpenAI and other providers
+
+Set your OpenAI key:
+
+```bash
+export OPENAI_API_KEY="sk-..."
+```
+
+To use a different provider, set `OPENAI_BASE_URL` to the provider
+endpoint and keep `OPENAI_API_KEY` pointing to the correct key:
+
+```bash
+export OPENAI_BASE_URL="https://openrouter.ai/api/v1"
+export OPENAI_API_KEY="your-provider-key"
+```
+
+## Development
+
+1. Install the test dependencies:
+
+```bash
+pip install -e .[test]
+```
+
+2. Run the test suite:
+
+```bash
+pytest
+```
+
+Use `mkdocs serve` to build the documentation locally.
+
+## License
+
+This project is released under the MIT license. See the `LICENSE` file for details.
+

{pygent-0.1.12 → pygent-0.1.14}/README.md

@@ -33,6 +33,7 @@ Behaviour can be adjusted via environment variables (see `docs/configuration.md`
 * `PYGENT_MODEL` – model name used for requests (default `gpt-4.1-mini`).
 * `PYGENT_IMAGE` – Docker image to create the container (default `python:3.12-slim`).
 * `PYGENT_USE_DOCKER` – set to `0` to disable Docker and run locally.
+* `PYGENT_MAX_TASKS` – maximum number of concurrent delegated tasks (default `3`).
 
 ## CLI usage
 

{pygent-0.1.12 → pygent-0.1.14}/pygent/__init__.py

@@ -10,6 +10,7 @@ from .agent import Agent, run_interactive  # noqa: E402,F401, must come after __
 from .models import Model, OpenAIModel  # noqa: E402,F401
 from .errors import PygentError, APIError  # noqa: E402,F401
 from .tools import register_tool, tool  # noqa: E402,F401
+from .task_manager import TaskManager  # noqa: E402,F401
 
 __all__ = [
     "Agent",
@@ -20,4 +21,5 @@ __all__ = [
     "APIError",
     "register_tool",
     "tool",
+    "TaskManager",
 ]

{pygent-0.1.12 → pygent-0.1.14}/pygent/agent.py

@@ -20,10 +20,10 @@ DEFAULT_MODEL = os.getenv("PYGENT_MODEL", "gpt-4.1-mini")
 SYSTEM_MSG = (
     "You are Pygent, a sandboxed coding assistant.\n"
     "Respond with JSON when you need to use a tool."
-    "If you need to stop, call the `stop` tool.\n"
+    "If you need to stop or finished you task, call the `stop` tool.\n"
     "You can use the following tools:\n"
     f"{json.dumps(tools.TOOL_SCHEMAS, indent=2)}\n"
-    "You can also use the `continue` tool to continue the conversation.\n"
+    "You can also use the `continue` tool to request user input or continue the conversation.\n"
 )
 
 console = Console()
@@ -44,7 +44,10 @@ class Agent:
             self.history.append({"role": "system", "content": self.system_msg})
 
     def step(self, user_msg: str):
+        """Execute one round of interaction with the model."""
+
         self.history.append({"role": "user", "content": user_msg})
+
         assistant_msg = self.model.chat(
             self.history, self.model_name, tools.TOOL_SCHEMAS
         )
@@ -60,12 +63,36 @@ class Agent:
             console.print(Panel(markdown_response, title="Resposta do Agente", title_align="left", border_style="cyan"))
         return assistant_msg
 
-    def run_until_stop(self, user_msg: str, max_steps: int = 10) -> None:
-        """Run steps automatically until the model calls the ``stop`` tool or
-        the step limit is reached."""
+    def run_until_stop(
+        self,
+        user_msg: str,
+        max_steps: int = 20,
+        step_timeout: float | None = None,
+        max_time: float | None = None,
+    ) -> None:
+        """Run steps until ``stop`` is called or limits are reached."""
+
+        if step_timeout is None:
+            env = os.getenv("PYGENT_STEP_TIMEOUT")
+            step_timeout = float(env) if env else None
+        if max_time is None:
+            env = os.getenv("PYGENT_TASK_TIMEOUT")
+            max_time = float(env) if env else None
+
         msg = user_msg
+        start = time.monotonic()
+        self._timed_out = False
         for _ in range(max_steps):
+            if max_time is not None and time.monotonic() - start > max_time:
+                self.history.append({"role": "system", "content": f"[timeout after {max_time}s]"})
+                self._timed_out = True
+                break
+            step_start = time.monotonic()
             assistant_msg = self.step(msg)
+            if step_timeout is not None and time.monotonic() - step_start > step_timeout:
+                self.history.append({"role": "system", "content": f"[timeout after {step_timeout}s]"})
+                self._timed_out = True
+                break
             calls = assistant_msg.tool_calls or []
             if any(c.function.name in ("stop", "continue") for c in calls):
                 break

{pygent-0.1.12 → pygent-0.1.14}/pygent/runtime.py

@@ -92,6 +92,24 @@ class Runtime:
         p.write_text(content, encoding="utf-8")
         return f"Wrote {p.relative_to(self.base_dir)}"
 
+    def read_file(self, path: Union[str, Path], binary: bool = False) -> str:
+        """Return the contents of a file relative to the workspace."""
+
+        p = self.base_dir / path
+        if not p.exists():
+            return f"file {p.relative_to(self.base_dir)} not found"
+        data = p.read_bytes()
+        if binary:
+            import base64
+
+            return base64.b64encode(data).decode()
+        try:
+            return data.decode()
+        except UnicodeDecodeError:
+            import base64
+
+            return base64.b64encode(data).decode()
+
     def cleanup(self) -> None:
         if self._use_docker and self.container is not None:
             try:

pygent-0.1.14/pygent/task_manager.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+"""Manage background tasks executed by sub-agents."""
+
+import os
+import shutil
+import threading
+import uuid
+from dataclasses import dataclass, field
+from typing import Callable, Dict, TYPE_CHECKING
+
+from .runtime import Runtime
+
+if TYPE_CHECKING:  # pragma: no cover - for type hints only
+    from .agent import Agent
+
+
+@dataclass
+class Task:
+    """Represents a delegated task."""
+
+    id: str
+    agent: "Agent"
+    thread: threading.Thread
+    status: str = field(default="running")
+
+
+class TaskManager:
+    """Launch agents asynchronously and track their progress."""
+
+    def __init__(
+        self,
+        agent_factory: Callable[[], "Agent"] | None = None,
+        max_tasks: int | None = None,
+    ) -> None:
+        from .agent import Agent  # local import to avoid circular dependency
+
+        env_max = os.getenv("PYGENT_MAX_TASKS")
+        self.max_tasks = max_tasks if max_tasks is not None else int(env_max or "3")
+        self.agent_factory = agent_factory or Agent
+        self.tasks: Dict[str, Task] = {}
+        self._lock = threading.Lock()
+
+    def start_task(
+        self,
+        prompt: str,
+        parent_rt: Runtime,
+        files: list[str] | None = None,
+        parent_depth: int = 0,
+        step_timeout: float | None = None,
+        task_timeout: float | None = None,
+    ) -> str:
+        """Create a new agent and run ``prompt`` asynchronously."""
+
+        if parent_depth >= 1:
+            raise RuntimeError("nested delegation is not allowed")
+
+        with self._lock:
+            active = sum(t.status == "running" for t in self.tasks.values())
+            if active >= self.max_tasks:
+                raise RuntimeError(f"max {self.max_tasks} tasks reached")
+
+        if step_timeout is None:
+            env = os.getenv("PYGENT_STEP_TIMEOUT")
+            step_timeout = float(env) if env else 60*5 # default 5 minutes
+        if task_timeout is None:
+            env = os.getenv("PYGENT_TASK_TIMEOUT")
+            task_timeout = float(env) if env else 60*20 # default 20 minutes
+
+        agent = self.agent_factory()
+        setattr(agent.runtime, "task_depth", parent_depth + 1)
+        if files:
+            for fp in files:
+                src = parent_rt.base_dir / fp
+                dest = agent.runtime.base_dir / fp
+                if src.is_dir():
+                    shutil.copytree(src, dest, dirs_exist_ok=True)
+                elif src.exists():
+                    dest.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copy(src, dest)
+        task_id = uuid.uuid4().hex[:8]
+        task = Task(id=task_id, agent=agent, thread=None)  # type: ignore[arg-type]
+
+        def run() -> None:
+            try:
+                agent.run_until_stop(
+                    prompt,
+                    step_timeout=step_timeout,
+                    max_time=task_timeout,
+                )
+                if getattr(agent, "_timed_out", False):
+                    task.status = f"timeout after {task_timeout}s"
+                else:
+                    task.status = "finished"
+            except Exception as exc:  # pragma: no cover - error propagation
+                task.status = f"error: {exc}"
+
+        t = threading.Thread(target=run, daemon=True)
+        task.thread = t
+        with self._lock:
+            self.tasks[task_id] = task
+        t.start()
+        return task_id
+
+    def status(self, task_id: str) -> str:
+        with self._lock:
+            task = self.tasks.get(task_id)
+        if not task:
+            return f"Task {task_id} not found"
+        return task.status
+
+    def collect_file(self, rt: Runtime, task_id: str, path: str) -> str:
+        """Copy a file from a task workspace into ``rt``."""
+
+        with self._lock:
+            task = self.tasks.get(task_id)
+        if not task:
+            return f"Task {task_id} not found"
+        src = task.agent.runtime.base_dir / path
+        if not src.exists():
+            return f"file {path} not found"
+        dest = rt.base_dir / path
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy(src, dest)
+        return f"Retrieved {dest.relative_to(rt.base_dir)}"

pygent-0.1.14/pygent/tools.py

@@ -0,0 +1,196 @@
+"""Tool registry and helper utilities."""
+from __future__ import annotations
+
+import json
+from typing import Any, Callable, Dict, List
+
+from .runtime import Runtime
+from .task_manager import TaskManager
+
+_task_manager: TaskManager | None = None
+
+
+def _get_manager() -> TaskManager:
+    global _task_manager
+    if _task_manager is None:
+        _task_manager = TaskManager()
+    return _task_manager
+
+
+# ---- registry ----
+TOOLS: Dict[str, Callable[..., str]] = {}
+TOOL_SCHEMAS: List[Dict[str, Any]] = []
+
+
+def register_tool(
+    name: str, description: str, parameters: Dict[str, Any], func: Callable[..., str]
+) -> None:
+    """Register a new callable tool."""
+    if name in TOOLS:
+        raise ValueError(f"tool {name} already registered")
+    TOOLS[name] = func
+    TOOL_SCHEMAS.append(
+        {
+            "type": "function",
+            "function": {
+                "name": name,
+                "description": description,
+                "parameters": parameters,
+            },
+        }
+    )
+
+
+def tool(name: str, description: str, parameters: Dict[str, Any]):
+    """Decorator for registering a tool."""
+
+    def decorator(func: Callable[..., str]) -> Callable[..., str]:
+        register_tool(name, description, parameters, func)
+        return func
+
+    return decorator
+
+
+def execute_tool(call: Any, rt: Runtime) -> str:  # pragma: no cover
+    """Dispatch a tool call."""
+    name = call.function.name
+    args: Dict[str, Any] = json.loads(call.function.arguments)
+    func = TOOLS.get(name)
+    if func is None:
+        return f"⚠️ unknown tool {name}"
+    return func(rt, **args)
+
+
+# ---- built-ins ----
+
+
+@tool(
+    name="bash",
+    description="Run a shell command inside the sandboxed container.",
+    parameters={
+        "type": "object",
+        "properties": {"cmd": {"type": "string", "description": "Command to execute"}},
+        "required": ["cmd"],
+    },
+)
+def _bash(rt: Runtime, cmd: str) -> str:
+    return rt.bash(cmd)
+
+
+@tool(
+    name="write_file",
+    description="Create or overwrite a file in the workspace.",
+    parameters={
+        "type": "object",
+        "properties": {"path": {"type": "string"}, "content": {"type": "string"}},
+        "required": ["path", "content"],
+    },
+)
+def _write_file(rt: Runtime, path: str, content: str) -> str:
+    return rt.write_file(path, content)
+
+
+@tool(
+    name="stop",
+    description="Stop the autonomous loop. This is a side-effect free tool that does not return any output. Use when finished some task or when you want to stop the agent.",
+    parameters={"type": "object", "properties": {}},
+)
+def _stop(rt: Runtime) -> str:  # pragma: no cover - side-effect free
+    return "Stopping."
+
+
+@tool(
+    name="continue",
+    description="Request user answer or input. If in your previous message you asked for user input, you can use this tool to continue the conversation.",
+    parameters={"type": "object", "properties": {}},
+)
+def _continue(rt: Runtime) -> str:  # pragma: no cover - side-effect free
+    return "Continuing the conversation."
+
+
+
+
+@tool(
+    name="delegate_task",
+    description="Create a background task using a new agent and return its ID.",
+    parameters={
+        "type": "object",
+        "properties": {
+            "prompt": {"type": "string", "description": "Instruction for the sub-agent"},
+            "files": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Files to copy to the sub-agent before starting",
+            },
+            "timeout": {"type": "number", "description": "Max seconds for the task"},
+            "step_timeout": {"type": "number", "description": "Time limit per step"},
+        },
+        "required": ["prompt"],
+    },
+)
+def _delegate_task(
+    rt: Runtime,
+    prompt: str,
+    files: list[str] | None = None,
+    timeout: float | None = None,
+    step_timeout: float | None = None,
+) -> str:
+    if getattr(rt, "task_depth", 0) >= 1:
+        return "error: delegation not allowed in sub-tasks"
+    try:
+        tid = _get_manager().start_task(
+            prompt,
+            parent_rt=rt,
+            files=files,
+            parent_depth=getattr(rt, "task_depth", 0),
+            step_timeout=step_timeout,
+            task_timeout=timeout,
+        )
+    except RuntimeError as exc:
+        return str(exc)
+    return f"started {tid}"
+
+
+@tool(
+    name="task_status",
+    description="Check the status of a delegated task.",
+    parameters={
+        "type": "object",
+        "properties": {"task_id": {"type": "string"}},
+        "required": ["task_id"],
+    },
+)
+def _task_status(rt: Runtime, task_id: str) -> str:
+    return _get_manager().status(task_id)
+
+
+@tool(
+    name="collect_file",
+    description="Retrieve a file from a delegated task into the main workspace.",
+    parameters={
+        "type": "object",
+        "properties": {
+            "task_id": {"type": "string"},
+            "path": {"type": "string"},
+        },
+        "required": ["task_id", "path"],
+    },
+)
+def _collect_file(rt: Runtime, task_id: str, path: str) -> str:
+    return _get_manager().collect_file(rt, task_id, path)
+
+
+@tool(
+    name="download_file",
+    description="Return the contents of a file from the workspace (base64 if binary)",
+    parameters={
+        "type": "object",
+        "properties": {
+            "path": {"type": "string"},
+            "binary": {"type": "boolean", "default": False},
+        },
+        "required": ["path"],
+    },
+)
+def _download_file(rt: Runtime, path: str, binary: bool = False) -> str:
+    return rt.read_file(path, binary=binary)

pygent-0.1.14/pygent.egg-info/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: pygent
+Version: 0.1.14
+Summary: Pygent is a minimalist coding assistant that runs commands in a Docker container when available and falls back to local execution. See https://marianochaves.github.io/pygent for documentation and https://github.com/marianochaves/pygent for the source code.
+Author-email: Mariano Chaves <mchaves.software@gmail.com>
+Project-URL: Documentation, https://marianochaves.github.io/pygent
+Project-URL: Repository, https://github.com/marianochaves/pygent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.7.0
+Requires-Dist: openai>=1.0.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == "docs"
+Provides-Extra: docker
+Requires-Dist: docker>=7.0.0; extra == "docker"
+Provides-Extra: ui
+Requires-Dist: gradio; extra == "ui"
+Dynamic: license-file
+
+# Pygent
+
+Pygent is a coding assistant that executes each request inside an isolated Docker container whenever possible. If Docker is unavailable (for instance on some Windows setups) the commands are executed locally instead. Full documentation is available in the `docs/` directory and at [marianochaves.github.io/pygent](https://marianochaves.github.io/pygent/).
+
+## Features
+
+* Runs commands in ephemeral containers (default image `python:3.12-slim`).
+* Integrates with OpenAI-compatible models to orchestrate each step.
+* Persists the conversation history during the session.
+* Provides a small Python API for use in other projects.
+* Optional web interface via `pygent-ui`.
+* Register your own tools and customise the system prompt.
+
+## Installation
+
+Installing from source is recommended:
+
+```bash
+pip install -e .
+```
+
+Python ≥ 3.9 is required. The package now bundles the `openai` client for model access.
+To run commands in Docker containers also install `pygent[docker]`.
+
+## Configuration
+
+Behaviour can be adjusted via environment variables (see `docs/configuration.md` for a complete list):
+
+* `OPENAI_API_KEY` &ndash; key used to access the OpenAI API.
+  Set this to your API key or a key from any compatible provider.
+* `OPENAI_BASE_URL` &ndash; base URL for OpenAI-compatible APIs
+  (defaults to ``https://api.openai.com/v1``).
+* `PYGENT_MODEL` &ndash; model name used for requests (default `gpt-4.1-mini`).
+* `PYGENT_IMAGE` &ndash; Docker image to create the container (default `python:3.12-slim`).
+* `PYGENT_USE_DOCKER` &ndash; set to `0` to disable Docker and run locally.
+* `PYGENT_MAX_TASKS` &ndash; maximum number of concurrent delegated tasks (default `3`).
+
+## CLI usage
+
+After installing run:
+
+```bash
+pygent
+```
+
+Use `--docker` to run commands inside a container (requires
+`pygent[docker]`). Use `--no-docker` or set `PYGENT_USE_DOCKER=0`
+to force local execution.
+
+Type messages normally; use `/exit` to end the session. Each command is executed
+in the container and the result shown in the terminal.
+Interactive programs that expect input (e.g. running `python` without a script)
+are not supported and will exit immediately.
+For a minimal web interface run `pygent-ui` instead (requires `pygent[ui]`).
+
+
+## API usage
+
+You can also interact directly with the Python code:
+
+```python
+from pygent import Agent
+
+ag = Agent()
+ag.step("echo 'Hello World'")
+# ... more steps
+ag.runtime.cleanup()
+```
+
+See the [examples](https://github.com/marianochaves/pygent/tree/main/examples) folder for more complete scripts. Models can be swapped by
+passing an object implementing the ``Model`` interface when creating the
+``Agent``. The default uses an OpenAI-compatible API, but custom models are
+easy to plug in.
+
+### Using OpenAI and other providers
+
+Set your OpenAI key:
+
+```bash
+export OPENAI_API_KEY="sk-..."
+```
+
+To use a different provider, set `OPENAI_BASE_URL` to the provider
+endpoint and keep `OPENAI_API_KEY` pointing to the correct key:
+
+```bash
+export OPENAI_BASE_URL="https://openrouter.ai/api/v1"
+export OPENAI_API_KEY="your-provider-key"
+```
+
+## Development
+
+1. Install the test dependencies:
+
+```bash
+pip install -e .[test]
+```
+
+2. Run the test suite:
+
+```bash
+pytest
+```
+
+Use `mkdocs serve` to build the documentation locally.
+
+## License
+
+This project is released under the MIT license. See the `LICENSE` file for details.
+

{pygent-0.1.12 → pygent-0.1.14}/pygent.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ pygent/models.py
 pygent/openai_compat.py
 pygent/py.typed
 pygent/runtime.py
+pygent/task_manager.py
 pygent/tools.py
 pygent/ui.py
 pygent.egg-info/PKG-INFO
@@ -22,5 +23,6 @@ tests/test_autorun.py
 tests/test_custom_model.py
 tests/test_error_handling.py
 tests/test_runtime.py
+tests/test_tasks.py
 tests/test_tools.py
 tests/test_version.py

{pygent-0.1.12 → pygent-0.1.14}/pyproject.toml

@@ -1,7 +1,8 @@
 [project]
 name = "pygent"
-version = "0.1.12"
+version = "0.1.14"
 description = "Pygent is a minimalist coding assistant that runs commands in a Docker container when available and falls back to local execution. See https://marianochaves.github.io/pygent for documentation and https://github.com/marianochaves/pygent for the source code."
+readme = "README.md"
 authors = [ { name = "Mariano Chaves", email = "mchaves.software@gmail.com" } ]
 requires-python = ">=3.9"
 dependencies = [

pygent-0.1.14/tests/test_tasks.py

@@ -0,0 +1,203 @@
+import os
+import sys
+import types
+import time
+
+sys.modules.setdefault('openai', types.ModuleType('openai'))
+sys.modules.setdefault('docker', types.ModuleType('docker'))
+
+# mocks for rich
+rich_mod = types.ModuleType('rich')
+console_mod = types.ModuleType('console')
+panel_mod = types.ModuleType('panel')
+markdown_mod = types.ModuleType('markdown')
+syntax_mod = types.ModuleType('syntax')
+console_mod.Console = lambda *a, **k: type('C', (), {'print': lambda *a, **k: None})()
+panel_mod.Panel = lambda *a, **k: None
+markdown_mod.Markdown = lambda *a, **k: None
+syntax_mod.Syntax = lambda *a, **k: None
+sys.modules.setdefault('rich', rich_mod)
+sys.modules.setdefault('rich.console', console_mod)
+sys.modules.setdefault('rich.panel', panel_mod)
+sys.modules.setdefault('rich.markdown', markdown_mod)
+sys.modules.setdefault('rich.syntax', syntax_mod)
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from pygent import Agent
+from pygent import openai_compat
+from pygent.task_manager import TaskManager
+from pygent.runtime import Runtime
+from pygent import tools
+
+class DummyModel:
+    def __init__(self):
+        self.count = 0
+    def chat(self, messages, model, tool_schemas):
+        self.count += 1
+        if self.count == 1:
+            return openai_compat.Message(
+                role='assistant',
+                content=None,
+                tool_calls=[
+                    openai_compat.ToolCall(
+                        id='1',
+                        type='function',
+                        function=openai_compat.ToolCallFunction(
+                            name='write_file',
+                            arguments='{"path": "foo.txt", "content": "bar"}'
+                        )
+                    )
+                ]
+            )
+        else:
+            return openai_compat.Message(
+                role='assistant',
+                content=None,
+                tool_calls=[
+                    openai_compat.ToolCall(
+                        id='2',
+                        type='function',
+                        function=openai_compat.ToolCallFunction(
+                            name='stop',
+                            arguments='{}'
+                        )
+                    )
+                ]
+            )
+
+class SlowModel(DummyModel):
+    """DummyModel variant that sleeps to simulate long-running tasks."""
+
+    def chat(self, messages, model, tool_schemas):
+        time.sleep(0.1)
+        return super().chat(messages, model, tool_schemas)
+
+def make_agent():
+    return Agent(runtime=Runtime(use_docker=False), model=DummyModel())
+
+def make_slow_agent():
+    return Agent(runtime=Runtime(use_docker=False), model=SlowModel())
+
+def test_delegate_and_collect_file(tmp_path):
+    tm = TaskManager(agent_factory=make_agent)
+    tools._task_manager = tm
+
+    rt = Runtime(use_docker=False)
+    task_id = tools._delegate_task(rt, prompt='run')
+    tid = task_id.split()[-1]
+    tm.tasks[tid].thread.join()
+
+    status = tools._task_status(Runtime(use_docker=False), task_id=tid)
+    assert status == 'finished'
+
+    main_rt = Runtime(use_docker=False)
+    msg = tools._collect_file(main_rt, task_id=tid, path='foo.txt')
+    assert 'Retrieved' in msg
+    copied = main_rt.base_dir / 'foo.txt'
+    assert copied.exists() and copied.read_text() == 'bar'
+    main_rt.cleanup()
+
+
+def test_delegate_with_files():
+    tm = TaskManager(agent_factory=make_agent)
+    tools._task_manager = tm
+
+    rt = Runtime(use_docker=False)
+    rt.write_file("data.txt", "hello")
+    tid_msg = tools._delegate_task(rt, prompt="run", files=["data.txt"])
+    tid = tid_msg.split()[-1]
+    tm.tasks[tid].thread.join()
+
+    child_path = tm.tasks[tid].agent.runtime.base_dir / "data.txt"
+    assert child_path.exists() and child_path.read_text() == "hello"
+
+
+def test_download_file():
+    rt = Runtime(use_docker=False)
+    rt.write_file("sample.txt", "hi")
+    content = tools._download_file(rt, path="sample.txt")
+    assert content == "hi"
+
+
+class DelegateModel:
+    def __init__(self):
+        self.count = 0
+    def chat(self, messages, model, tool_schemas):
+        self.count += 1
+        if self.count == 1:
+            return openai_compat.Message(
+                role='assistant',
+                content=None,
+                tool_calls=[
+                    openai_compat.ToolCall(
+                        id='1',
+                        type='function',
+                        function=openai_compat.ToolCallFunction(
+                            name='delegate_task',
+                            arguments='{"prompt": "noop"}'
+                        )
+                    )
+                ]
+            )
+        else:
+            return openai_compat.Message(
+                role='assistant',
+                content=None,
+                tool_calls=[
+                    openai_compat.ToolCall(
+                        id='2',
+                        type='function',
+                        function=openai_compat.ToolCallFunction(
+                            name='stop',
+                            arguments='{}'
+                        )
+                    )
+                ]
+            )
+
+
+def make_delegate_agent():
+    return Agent(runtime=Runtime(use_docker=False), model=DelegateModel())
+
+
+def test_no_nested_delegation():
+    tm = TaskManager(agent_factory=make_delegate_agent, max_tasks=2)
+    tools._task_manager = tm
+
+    tid_msg = tools._delegate_task(Runtime(use_docker=False), prompt='run')
+    tid = tid_msg.split()[-1]
+    tm.tasks[tid].thread.join()
+
+    # No new tasks should have been created inside the sub-agent
+    assert len(tm.tasks) == 1
+
+
+def test_task_limit():
+    tm = TaskManager(agent_factory=make_slow_agent, max_tasks=1)
+    tools._task_manager = tm
+
+    first = tools._delegate_task(Runtime(use_docker=False), prompt='run')
+    assert first.startswith('started')
+    tid = first.split()[-1]
+
+    second = tools._delegate_task(Runtime(use_docker=False), prompt='run')
+    assert 'max' in second
+
+    tm.tasks[tid].thread.join()
+
+
+def test_step_timeout():
+    ag = make_slow_agent()
+    ag.run_until_stop('run', step_timeout=0.05, max_steps=1)
+    assert 'timeout' in ag.history[-1]["content"]
+
+
+def test_task_timeout():
+    tm = TaskManager(agent_factory=make_slow_agent, max_tasks=1)
+    tools._task_manager = tm
+    rt = Runtime(use_docker=False)
+    tid = tm.start_task('run', rt, task_timeout=0.05, step_timeout=0.01)
+    tm.tasks[tid].thread.join()
+    assert 'timeout' in tm.status(tid)
+

pygent-0.1.12/PKG-INFO

@@ -1,20 +0,0 @@
-Metadata-Version: 2.4
-Name: pygent
-Version: 0.1.12
-Summary: Pygent is a minimalist coding assistant that runs commands in a Docker container when available and falls back to local execution. See https://marianochaves.github.io/pygent for documentation and https://github.com/marianochaves/pygent for the source code.
-Author-email: Mariano Chaves <mchaves.software@gmail.com>
-Project-URL: Documentation, https://marianochaves.github.io/pygent
-Project-URL: Repository, https://github.com/marianochaves/pygent
-Requires-Python: >=3.9
-License-File: LICENSE
-Requires-Dist: rich>=13.7.0
-Requires-Dist: openai>=1.0.0
-Provides-Extra: test
-Requires-Dist: pytest; extra == "test"
-Provides-Extra: docs
-Requires-Dist: mkdocs; extra == "docs"
-Provides-Extra: docker
-Requires-Dist: docker>=7.0.0; extra == "docker"
-Provides-Extra: ui
-Requires-Dist: gradio; extra == "ui"
-Dynamic: license-file

pygent-0.1.12/pygent/tools.py

@@ -1,99 +0,0 @@
-"""Tool registry and helper utilities."""
-from __future__ import annotations
-
-import json
-from typing import Any, Callable, Dict, List
-
-from .runtime import Runtime
-
-
-# ---- registry ----
-TOOLS: Dict[str, Callable[..., str]] = {}
-TOOL_SCHEMAS: List[Dict[str, Any]] = []
-
-
-def register_tool(
-    name: str, description: str, parameters: Dict[str, Any], func: Callable[..., str]
-) -> None:
-    """Register a new callable tool."""
-    if name in TOOLS:
-        raise ValueError(f"tool {name} already registered")
-    TOOLS[name] = func
-    TOOL_SCHEMAS.append(
-        {
-            "type": "function",
-            "function": {
-                "name": name,
-                "description": description,
-                "parameters": parameters,
-            },
-        }
-    )
-
-
-def tool(name: str, description: str, parameters: Dict[str, Any]):
-    """Decorator for registering a tool."""
-
-    def decorator(func: Callable[..., str]) -> Callable[..., str]:
-        register_tool(name, description, parameters, func)
-        return func
-
-    return decorator
-
-
-def execute_tool(call: Any, rt: Runtime) -> str:  # pragma: no cover
-    """Dispatch a tool call."""
-    name = call.function.name
-    args: Dict[str, Any] = json.loads(call.function.arguments)
-    func = TOOLS.get(name)
-    if func is None:
-        return f"⚠️ unknown tool {name}"
-    return func(rt, **args)
-
-
-# ---- built-ins ----
-
-
-@tool(
-    name="bash",
-    description="Run a shell command inside the sandboxed container.",
-    parameters={
-        "type": "object",
-        "properties": {"cmd": {"type": "string", "description": "Command to execute"}},
-        "required": ["cmd"],
-    },
-)
-def _bash(rt: Runtime, cmd: str) -> str:
-    return rt.bash(cmd)
-
-
-@tool(
-    name="write_file",
-    description="Create or overwrite a file in the workspace.",
-    parameters={
-        "type": "object",
-        "properties": {"path": {"type": "string"}, "content": {"type": "string"}},
-        "required": ["path", "content"],
-    },
-)
-def _write_file(rt: Runtime, path: str, content: str) -> str:
-    return rt.write_file(path, content)
-
-
-@tool(
-    name="stop",
-    description="Stop the autonomous loop.",
-    parameters={"type": "object", "properties": {}},
-)
-def _stop(rt: Runtime) -> str:  # pragma: no cover - side-effect free
-    return "Stopping."
-
-
-@tool(
-    name="continue",
-    description="Continue the conversation.",
-    parameters={"type": "object", "properties": {}},
-)
-def _continue(rt: Runtime) -> str:  # pragma: no cover - side-effect free
-    return "Continuing the conversation."
-

pygent-0.1.12/pygent.egg-info/PKG-INFO

@@ -1,20 +0,0 @@
-Metadata-Version: 2.4
-Name: pygent
-Version: 0.1.12
-Summary: Pygent is a minimalist coding assistant that runs commands in a Docker container when available and falls back to local execution. See https://marianochaves.github.io/pygent for documentation and https://github.com/marianochaves/pygent for the source code.
-Author-email: Mariano Chaves <mchaves.software@gmail.com>
-Project-URL: Documentation, https://marianochaves.github.io/pygent
-Project-URL: Repository, https://github.com/marianochaves/pygent
-Requires-Python: >=3.9
-License-File: LICENSE
-Requires-Dist: rich>=13.7.0
-Requires-Dist: openai>=1.0.0
-Provides-Extra: test
-Requires-Dist: pytest; extra == "test"
-Provides-Extra: docs
-Requires-Dist: mkdocs; extra == "docs"
-Provides-Extra: docker
-Requires-Dist: docker>=7.0.0; extra == "docker"
-Provides-Extra: ui
-Requires-Dist: gradio; extra == "ui"
-Dynamic: license-file