pygent 0.1.15__tar.gz → 0.1.16__tar.gz

{pygent-0.1.15 → pygent-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygent
-Version: 0.1.15
+Version: 0.1.16
 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
@@ -57,6 +57,12 @@ Behaviour can be adjusted via environment variables (see `docs/configuration.md`
 * `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`).
 
+Settings can also be read from a `pygent.toml` file. See
+[examples/sample_config.toml](https://github.com/marianochaves/pygent/blob/main/examples/sample_config.toml)
+and the accompanying
+[config_file_example.py](https://github.com/marianochaves/pygent/blob/main/examples/config_file_example.py)
+script for a working demonstration that generates tests using a delegated agent.
+
 ## CLI usage
 
 After installing run:

{pygent-0.1.15 → pygent-0.1.16}/README.md

@@ -35,6 +35,12 @@ Behaviour can be adjusted via environment variables (see `docs/configuration.md`
 * `PYGENT_USE_DOCKER` – set to `0` to disable Docker and run locally.
 * `PYGENT_MAX_TASKS` – maximum number of concurrent delegated tasks (default `3`).
 
+Settings can also be read from a `pygent.toml` file. See
+[examples/sample_config.toml](https://github.com/marianochaves/pygent/blob/main/examples/sample_config.toml)
+and the accompanying
+[config_file_example.py](https://github.com/marianochaves/pygent/blob/main/examples/config_file_example.py)
+script for a working demonstration that generates tests using a delegated agent.
+
 ## CLI usage
 
 After installing run:

{pygent-0.1.15 → pygent-0.1.16}/pygent/agent.py

@@ -15,12 +15,16 @@ from rich.markdown import Markdown
 from .runtime import Runtime
 from . import tools
 from .models import Model, OpenAIModel
+from .persona import Persona
 
-DEFAULT_PERSONA = os.getenv("PYGENT_PERSONA", "You are Pygent, a sandboxed coding assistant.")
+DEFAULT_PERSONA = Persona(
+    os.getenv("PYGENT_PERSONA_NAME", "Pygent"),
+    os.getenv("PYGENT_PERSONA", "a sandboxed coding assistant."),
+)
 
-def build_system_msg(persona: str) -> str:
+def build_system_msg(persona: Persona) -> str:
     return (
-        f"{persona}\n"
+        f"You are {persona.name}. {persona.description}\n"
         "Respond with JSON when you need to use a tool."
         "If you need to stop or finished you task, call the `stop` tool.\n"
         "You can use the following tools:\n"
@@ -41,7 +45,7 @@ class Agent:
     runtime: Runtime = field(default_factory=Runtime)
     model: Model = field(default_factory=OpenAIModel)
     model_name: str = DEFAULT_MODEL
-    persona: str = DEFAULT_PERSONA
+    persona: Persona = field(default_factory=lambda: DEFAULT_PERSONA)
     system_msg: str = field(default_factory=lambda: build_system_msg(DEFAULT_PERSONA))
     history: List[Dict[str, Any]] = field(default_factory=list)
 

{pygent-0.1.15 → pygent-0.1.16}/pygent/config.py

@@ -1,13 +1,15 @@
 import os
+import json
 import tomllib
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, List, Mapping
 
 DEFAULT_CONFIG_FILES = [
     Path("pygent.toml"),
     Path.home() / ".pygent.toml",
 ]
 
+
 def load_config(path: str | os.PathLike[str] | None = None) -> Dict[str, Any]:
     """Load configuration from a TOML file and set environment variables.
 
@@ -27,14 +29,29 @@ def load_config(path: str | os.PathLike[str] | None = None) -> Dict[str, Any]:
     # update environment without overwriting existing values
     if "persona" in config and "PYGENT_PERSONA" not in os.environ:
         os.environ["PYGENT_PERSONA"] = str(config["persona"])
-    if "task_personas" in config and "PYGENT_TASK_PERSONAS" not in os.environ:
-        if isinstance(config["task_personas"], list):
-            os.environ["PYGENT_TASK_PERSONAS"] = os.pathsep.join(str(p) for p in config["task_personas"])
-        else:
-            os.environ["PYGENT_TASK_PERSONAS"] = str(config["task_personas"])
+    if "persona_name" in config and "PYGENT_PERSONA_NAME" not in os.environ:
+        os.environ["PYGENT_PERSONA_NAME"] = str(config["persona_name"])
+    if "task_personas" in config:
+        personas = config["task_personas"]
+        if isinstance(personas, list) and personas and isinstance(personas[0], Mapping):
+            if "PYGENT_TASK_PERSONAS_JSON" not in os.environ:
+                os.environ["PYGENT_TASK_PERSONAS_JSON"] = json.dumps(personas)
+            if "PYGENT_TASK_PERSONAS" not in os.environ:
+                os.environ["PYGENT_TASK_PERSONAS"] = os.pathsep.join(
+                    str(p.get("name", "")) for p in personas
+                )
+        elif "PYGENT_TASK_PERSONAS" not in os.environ:
+            if isinstance(personas, list):
+                os.environ["PYGENT_TASK_PERSONAS"] = os.pathsep.join(
+                    str(p) for p in personas
+                )
+            else:
+                os.environ["PYGENT_TASK_PERSONAS"] = str(personas)
     if "initial_files" in config and "PYGENT_INIT_FILES" not in os.environ:
         if isinstance(config["initial_files"], list):
-            os.environ["PYGENT_INIT_FILES"] = os.pathsep.join(str(p) for p in config["initial_files"])
+            os.environ["PYGENT_INIT_FILES"] = os.pathsep.join(
+                str(p) for p in config["initial_files"]
+            )
         else:
             os.environ["PYGENT_INIT_FILES"] = str(config["initial_files"])
     return config

pygent-0.1.16/pygent/persona.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+@dataclass
+class Persona:
+    """Representa uma persona com nome e descricao."""
+    name: str
+    description: str
+

{pygent-0.1.15 → pygent-0.1.16}/pygent/task_manager.py

@@ -3,12 +3,15 @@ from __future__ import annotations
 """Manage background tasks executed by sub-agents."""
 
 import os
+import json
 import shutil
 import threading
 import uuid
 from dataclasses import dataclass, field
 from typing import Callable, Dict, TYPE_CHECKING
 
+from .persona import Persona
+
 from .runtime import Runtime
 
 if TYPE_CHECKING:  # pragma: no cover - for type hints only
@@ -32,7 +35,7 @@ class TaskManager:
         self,
         agent_factory: Callable[..., "Agent"] | None = None,
         max_tasks: int | None = None,
-        personas: list[str] | None = None,
+        personas: list[Persona] | None = None,
     ) -> None:
         from .agent import Agent  # local import to avoid circular dependency
 
@@ -42,11 +45,33 @@ class TaskManager:
             self.agent_factory = lambda p=None: Agent(persona=p)
         else:
             self.agent_factory = agent_factory
+        env_personas_json = os.getenv("PYGENT_TASK_PERSONAS_JSON")
+        if personas is None and env_personas_json:
+            try:
+                data = json.loads(env_personas_json)
+                if isinstance(data, list):
+                    personas = [
+                        Persona(p.get("name", ""), p.get("description", ""))
+                        for p in data
+                        if isinstance(p, dict)
+                    ]
+            except Exception:
+                personas = None
         env_personas = os.getenv("PYGENT_TASK_PERSONAS")
         if personas is None and env_personas:
-            personas = [p.strip() for p in env_personas.split(os.pathsep) if p.strip()]
-        default_persona = os.getenv("PYGENT_PERSONA", "You are Pygent, a sandboxed coding assistant.")
-        self.personas = personas or [default_persona]
+            personas = [
+                Persona(p.strip(), "")
+                for p in env_personas.split(os.pathsep)
+                if p.strip()
+            ]
+        if personas is None:
+            personas = [
+                Persona(
+                    os.getenv("PYGENT_PERSONA_NAME", "Pygent"),
+                    os.getenv("PYGENT_PERSONA", "a sandboxed coding assistant."),
+                )
+            ]
+        self.personas = personas
         self._persona_idx = 0
         self.tasks: Dict[str, Task] = {}
         self._lock = threading.Lock()
@@ -59,8 +84,12 @@ class TaskManager:
         parent_depth: int = 0,
         step_timeout: float | None = None,
         task_timeout: float | None = None,
+        persona: Persona | str | None = None,
     ) -> str:
-        """Create a new agent and run ``prompt`` asynchronously."""
+        """Create a new agent and run ``prompt`` asynchronously.
+
+        ``persona`` overrides the default rotation used for delegated tasks.
+        """
 
         if parent_depth >= 1:
             raise RuntimeError("nested delegation is not allowed")
@@ -72,13 +101,17 @@ class TaskManager:
 
         if step_timeout is None:
             env = os.getenv("PYGENT_STEP_TIMEOUT")
-            step_timeout = float(env) if env else 60*5 # default 5 minutes
+            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
-
-        persona = self.personas[self._persona_idx % len(self.personas)]
-        self._persona_idx += 1
+            task_timeout = float(env) if env else 60 * 20  # default 20 minutes
+
+        if persona is None:
+            persona = self.personas[self._persona_idx % len(self.personas)]
+            self._persona_idx += 1
+        elif isinstance(persona, str):
+            match = next((p for p in self.personas if p.name == persona), None)
+            persona = match or Persona(persona, "")
         try:
             agent = self.agent_factory(persona)
         except TypeError:

{pygent-0.1.15 → pygent-0.1.16}/pygent/tools.py

@@ -122,6 +122,7 @@ def _continue(rt: Runtime) -> str:  # pragma: no cover - side-effect free
                 "items": {"type": "string"},
                 "description": "Files to copy to the sub-agent before starting",
             },
+            "persona": {"type": "string", "description": "Persona for the sub-agent"},
             "timeout": {"type": "number", "description": "Max seconds for the task"},
             "step_timeout": {"type": "number", "description": "Time limit per step"},
         },
@@ -134,6 +135,7 @@ def _delegate_task(
     files: list[str] | None = None,
     timeout: float | None = None,
     step_timeout: float | None = None,
+    persona: str | None = None,
 ) -> str:
     if getattr(rt, "task_depth", 0) >= 1:
         return "error: delegation not allowed in sub-tasks"
@@ -145,12 +147,64 @@ def _delegate_task(
             parent_depth=getattr(rt, "task_depth", 0),
             step_timeout=step_timeout,
             task_timeout=timeout,
+            persona=persona,
         )
     except RuntimeError as exc:
         return str(exc)
     return f"started {tid}"
 
 
+@tool(
+    name="delegate_persona_task",
+    description="Create a background task with a specific persona and return its ID.",
+    parameters={
+        "type": "object",
+        "properties": {
+            "prompt": {"type": "string", "description": "Instruction for the sub-agent"},
+            "persona": {"type": "string", "description": "Persona 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", "persona"],
+    },
+)
+def _delegate_persona_task(
+    rt: Runtime,
+    prompt: str,
+    persona: str,
+    files: list[str] | None = None,
+    timeout: float | None = None,
+    step_timeout: float | None = None,
+) -> str:
+    return _delegate_task(
+        rt,
+        prompt=prompt,
+        files=files,
+        timeout=timeout,
+        step_timeout=step_timeout,
+        persona=persona,
+    )
+
+
+@tool(
+    name="list_personas",
+    description="Return the available personas for delegated agents.",
+    parameters={"type": "object", "properties": {}},
+)
+def _list_personas(rt: Runtime) -> str:
+    """Return JSON list of personas."""
+    personas = [
+        {"name": p.name, "description": p.description}
+        for p in _get_manager().personas
+    ]
+    return json.dumps(personas)
+
+
 @tool(
     name="task_status",
     description="Check the status of a delegated task.",

{pygent-0.1.15 → pygent-0.1.16}/pygent.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygent
-Version: 0.1.15
+Version: 0.1.16
 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
@@ -57,6 +57,12 @@ Behaviour can be adjusted via environment variables (see `docs/configuration.md`
 * `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`).
 
+Settings can also be read from a `pygent.toml` file. See
+[examples/sample_config.toml](https://github.com/marianochaves/pygent/blob/main/examples/sample_config.toml)
+and the accompanying
+[config_file_example.py](https://github.com/marianochaves/pygent/blob/main/examples/config_file_example.py)
+script for a working demonstration that generates tests using a delegated agent.
+
 ## CLI usage
 
 After installing run:

{pygent-0.1.15 → pygent-0.1.16}/pygent.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ pygent/config.py
 pygent/errors.py
 pygent/models.py
 pygent/openai_compat.py
+pygent/persona.py
 pygent/py.typed
 pygent/runtime.py
 pygent/task_manager.py

{pygent-0.1.15 → pygent-0.1.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pygent"
-version = "0.1.15"
+version = "0.1.16"
 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" } ]

pygent-0.1.16/tests/test_config.py

@@ -0,0 +1,75 @@
+import os
+import sys
+import types
+import json
+
+sys.modules.setdefault("openai", types.ModuleType("openai"))
+sys.modules.setdefault("docker", types.ModuleType("docker"))
+
+# minimal mocks for rich
+rich_mod = types.ModuleType("rich")
+console_mod = types.ModuleType("console")
+panel_mod = types.ModuleType("panel")
+markdown_mod = types.ModuleType("markdown")
+console_mod.Console = lambda *a, **k: None
+panel_mod.Panel = lambda *a, **k: None
+markdown_mod.Markdown = 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.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from pygent.config import load_config
+from pygent.runtime import Runtime
+from pygent.task_manager import TaskManager
+from pygent.persona import Persona
+
+
+def test_load_config(tmp_path, monkeypatch):
+    cfg = tmp_path / "pygent.toml"
+    cfg.write_text(
+        'persona="bot"\n'
+        'persona_name="Bot"\n'
+        'initial_files=["seed.txt"]\n'
+        '[[task_personas]]\nname="a"\ndescription="desc a"\n'
+        '[[task_personas]]\nname="b"\ndescription="desc b"\n'
+    )
+    (tmp_path / "seed.txt").write_text("seed")
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("PYGENT_PERSONA", raising=False)
+    monkeypatch.delenv("PYGENT_TASK_PERSONAS", raising=False)
+    monkeypatch.delenv("PYGENT_TASK_PERSONAS_JSON", raising=False)
+    monkeypatch.delenv("PYGENT_INIT_FILES", raising=False)
+    monkeypatch.delenv("PYGENT_PERSONA_NAME", raising=False)
+    load_config()
+    assert os.getenv("PYGENT_PERSONA") == "bot"
+    assert os.getenv("PYGENT_PERSONA_NAME") == "Bot"
+    assert os.getenv("PYGENT_TASK_PERSONAS") == os.pathsep.join(["a", "b"])
+    data = json.loads(os.getenv("PYGENT_TASK_PERSONAS_JSON"))
+    assert data[0]["description"] == "desc a"
+    assert os.getenv("PYGENT_INIT_FILES") == "seed.txt"
+    rt = Runtime(use_docker=False)
+    assert (rt.base_dir / "seed.txt").exists()
+    rt.cleanup()
+
+
+def test_task_manager_personas(monkeypatch):
+    created = []
+
+    def factory(p):
+        created.append(p)
+        ag = types.SimpleNamespace(
+            runtime=Runtime(use_docker=False), model=None, persona=p
+        )
+        ag.run_until_stop = lambda *a, **k: None
+        return ag
+
+    tm = TaskManager(
+        agent_factory=factory, personas=[Persona("one", ""), Persona("two", "")]
+    )
+    tm.start_task("noop", Runtime(use_docker=False))
+    tm.start_task("noop", Runtime(use_docker=False))
+    tm.tasks[next(iter(tm.tasks))].thread.join()
+    assert [p.name for p in created] == ["one", "two"]

{pygent-0.1.15 → pygent-0.1.16}/tests/test_tasks.py

@@ -2,70 +2,74 @@ import os
 import sys
 import types
 import time
+import json
 
-sys.modules.setdefault('openai', types.ModuleType('openai'))
-sys.modules.setdefault('docker', types.ModuleType('docker'))
+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})()
+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.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__), '..')))
+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.persona import Persona
 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',
+                role="assistant",
                 content=None,
                 tool_calls=[
                     openai_compat.ToolCall(
-                        id='1',
-                        type='function',
+                        id="1",
+                        type="function",
                         function=openai_compat.ToolCallFunction(
-                            name='write_file',
-                            arguments='{"path": "foo.txt", "content": "bar"}'
-                        )
+                            name="write_file",
+                            arguments='{"path": "foo.txt", "content": "bar"}',
+                        ),
                     )
-                ]
+                ],
             )
         else:
             return openai_compat.Message(
-                role='assistant',
+                role="assistant",
                 content=None,
                 tool_calls=[
                     openai_compat.ToolCall(
-                        id='2',
-                        type='function',
+                        id="2",
+                        type="function",
                         function=openai_compat.ToolCallFunction(
-                            name='stop',
-                            arguments='{}'
-                        )
+                            name="stop", arguments="{}"
+                        ),
                     )
-                ]
+                ],
             )
 
+
 class SlowModel(DummyModel):
     """DummyModel variant that sleeps to simulate long-running tasks."""
 
@@ -73,29 +77,32 @@ class SlowModel(DummyModel):
         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')
+    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'
+    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'
+    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()
 
 
@@ -123,37 +130,36 @@ def test_download_file():
 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',
+                role="assistant",
                 content=None,
                 tool_calls=[
                     openai_compat.ToolCall(
-                        id='1',
-                        type='function',
+                        id="1",
+                        type="function",
                         function=openai_compat.ToolCallFunction(
-                            name='delegate_task',
-                            arguments='{"prompt": "noop"}'
-                        )
+                            name="delegate_task", arguments='{"prompt": "noop"}'
+                        ),
                     )
-                ]
+                ],
             )
         else:
             return openai_compat.Message(
-                role='assistant',
+                role="assistant",
                 content=None,
                 tool_calls=[
                     openai_compat.ToolCall(
-                        id='2',
-                        type='function',
+                        id="2",
+                        type="function",
                         function=openai_compat.ToolCallFunction(
-                            name='stop',
-                            arguments='{}'
-                        )
+                            name="stop", arguments="{}"
+                        ),
                     )
-                ]
+                ],
             )
 
 
@@ -165,7 +171,7 @@ 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_msg = tools._delegate_task(Runtime(use_docker=False), prompt="run")
     tid = tid_msg.split()[-1]
     tm.tasks[tid].thread.join()
 
@@ -177,27 +183,67 @@ 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')
+    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
+    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"]
+    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)
+    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)
+
+
+def test_delegate_persona_task():
+    created = []
+
+    def factory(p):
+        created.append(p)
+        ag = types.SimpleNamespace(
+            runtime=Runtime(use_docker=False), model=None, persona=p
+        )
+        ag.run_until_stop = lambda *a, **k: None
+        return ag
+
+    tm = TaskManager(agent_factory=factory)
+    tools._task_manager = tm
+
+    rt = Runtime(use_docker=False)
+    tid_msg = tools._delegate_persona_task(rt, prompt="run", persona="tester")
+    tid = tid_msg.split()[-1]
     tm.tasks[tid].thread.join()
-    assert 'timeout' in tm.status(tid)
 
+    assert [p.name for p in created] == ["tester"]
+
+
+def test_list_personas():
+    tm = TaskManager(personas=[Persona("a", ""), Persona("b", "")])
+    tools._task_manager = tm
+    rt = Runtime(use_docker=False)
+    result = tools._list_personas(rt)
+    assert json.loads(result) == [
+        {"name": "a", "description": ""},
+        {"name": "b", "description": ""},
+    ]
+
+
+def test_personas_from_env(monkeypatch):
+    monkeypatch.setenv(
+        "PYGENT_TASK_PERSONAS_JSON", '[{"name":"env","description":"desc"}]'
+    )
+    tm = TaskManager()
+    assert tm.personas[0].name == "env" and tm.personas[0].description == "desc"

pygent-0.1.15/tests/test_config.py

@@ -1,56 +0,0 @@
-import os
-import sys
-import types
-
-sys.modules.setdefault('openai', types.ModuleType('openai'))
-sys.modules.setdefault('docker', types.ModuleType('docker'))
-
-# minimal mocks for rich
-rich_mod = types.ModuleType('rich')
-console_mod = types.ModuleType('console')
-panel_mod = types.ModuleType('panel')
-markdown_mod = types.ModuleType('markdown')
-console_mod.Console = lambda *a, **k: None
-panel_mod.Panel = lambda *a, **k: None
-markdown_mod.Markdown = 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.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
-
-from pygent.config import load_config
-from pygent.runtime import Runtime
-from pygent.task_manager import TaskManager
-
-
-def test_load_config(tmp_path, monkeypatch):
-    cfg = tmp_path / "pygent.toml"
-    cfg.write_text('persona="bot"\ntask_personas=["a","b"]\ninitial_files=["seed.txt"]')
-    (tmp_path / "seed.txt").write_text("seed")
-    monkeypatch.chdir(tmp_path)
-    monkeypatch.delenv("PYGENT_PERSONA", raising=False)
-    monkeypatch.delenv("PYGENT_TASK_PERSONAS", raising=False)
-    monkeypatch.delenv("PYGENT_INIT_FILES", raising=False)
-    load_config()
-    assert os.getenv("PYGENT_PERSONA") == "bot"
-    assert os.getenv("PYGENT_TASK_PERSONAS") == os.pathsep.join(["a", "b"])
-    assert os.getenv("PYGENT_INIT_FILES") == "seed.txt"
-    rt = Runtime(use_docker=False)
-    assert (rt.base_dir / "seed.txt").exists()
-    rt.cleanup()
-
-
-def test_task_manager_personas(monkeypatch):
-    created = []
-    def factory(p):
-        created.append(p)
-        ag = types.SimpleNamespace(runtime=Runtime(use_docker=False), model=None, persona=p)
-        ag.run_until_stop = lambda *a, **k: None
-        return ag
-    tm = TaskManager(agent_factory=factory, personas=["one","two"])
-    tm.start_task("noop", Runtime(use_docker=False))
-    tm.start_task("noop", Runtime(use_docker=False))
-    tm.tasks[next(iter(tm.tasks))].thread.join()
-    assert created == ["one","two"]