pygent 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

pygent/__init__.py

@@ -8,5 +8,16 @@ except _metadata.PackageNotFoundError:  # pragma: no cover - fallback for tests
 
 from .agent import Agent, run_interactive  # noqa: E402,F401, must come after __version__
 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
 
-__all__ = ["Agent", "run_interactive", "Model", "OpenAIModel"]
+__all__ = [
+    "Agent",
+    "run_interactive",
+    "Model",
+    "OpenAIModel",
+    "PygentError",
+    "APIError",
+    "register_tool",
+    "tool",
+]

pygent/agent.py

@@ -10,15 +10,20 @@ from typing import Any, Dict, List
 
 from rich.console import Console
 from rich.panel import Panel
+from rich.markdown import Markdown
 
 from .runtime import Runtime
-from .tools import TOOL_SCHEMAS, execute_tool
+from . import tools
 from .models import Model, OpenAIModel
 
 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"
+    "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"
 )
 
 console = Console()
@@ -31,22 +36,28 @@ class Agent:
     runtime: Runtime = field(default_factory=Runtime)
     model: Model = field(default_factory=OpenAIModel)
     model_name: str = DEFAULT_MODEL
-    history: List[Dict[str, Any]] = field(default_factory=lambda: [
-        {"role": "system", "content": SYSTEM_MSG}
-    ])
+    system_msg: str = SYSTEM_MSG
+    history: List[Dict[str, Any]] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        if not self.history:
+            self.history.append({"role": "system", "content": self.system_msg})
 
     def step(self, user_msg: str):
         self.history.append({"role": "user", "content": user_msg})
-        assistant_msg = self.model.chat(self.history, self.model_name, TOOL_SCHEMAS)
+        assistant_msg = self.model.chat(
+            self.history, self.model_name, tools.TOOL_SCHEMAS
+        )
         self.history.append(assistant_msg)
 
         if assistant_msg.tool_calls:
             for call in assistant_msg.tool_calls:
-                output = execute_tool(call, self.runtime)
+                output = tools.execute_tool(call, self.runtime)
                 self.history.append({"role": "tool", "content": output, "tool_call_id": call.id})
                 console.print(Panel(output, title=f"tool:{call.function.name}"))
         else:
-            console.print(assistant_msg.content)
+            markdown_response = Markdown(assistant_msg.content)
+            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:
@@ -56,7 +67,7 @@ class Agent:
         for _ in range(max_steps):
             assistant_msg = self.step(msg)
             calls = assistant_msg.tool_calls or []
-            if any(c.function.name == "stop" for c in calls):
+            if any(c.function.name in ("stop", "continue") for c in calls):
                 break
             msg = "continue"
 
@@ -66,9 +77,9 @@ def run_interactive(use_docker: bool | None = None) -> None:  # pragma: no cover
     console.print("[bold green]Pygent[/] iniciado. (digite /exit para sair)")
     try:
         while True:
-            user_msg = console.input("[cyan]vc> [/]" )
+            user_msg = console.input("[cyan]user> [/]" )
             if user_msg.strip() in {"/exit", "quit", "q"}:
                 break
-            agent.step(user_msg)
+            agent.run_until_stop(user_msg)
     finally:
         agent.runtime.cleanup()

pygent/errors.py

@@ -0,0 +1,6 @@
+class PygentError(Exception):
+    """Base error for the Pygent package."""
+
+
+class APIError(PygentError):
+    """Raised when the OpenAI API call fails."""

pygent/models.py

@@ -10,6 +10,7 @@ except ModuleNotFoundError:  # pragma: no cover - fallback to bundled client
     from . import openai_compat as openai
 
 from .openai_compat import Message
+from .errors import APIError
 
 
 class Model(Protocol):
@@ -24,10 +25,13 @@ class OpenAIModel:
     """Default model using the OpenAI-compatible API."""
 
     def chat(self, messages: List[Dict[str, Any]], model: str, tools: Any) -> Message:
-        resp = openai.chat.completions.create(
-            model=model,
-            messages=messages,
-            tools=tools,
-            tool_choice="auto",
-        )
-        return resp.choices[0].message
+        try:
+            resp = openai.chat.completions.create(
+                model=model,
+                messages=messages,
+                tools=tools,
+                tool_choice="auto",
+            )
+            return resp.choices[0].message
+        except Exception as exc:
+            raise APIError(str(exc)) from exc

pygent/openai_compat.py

@@ -2,7 +2,9 @@ import os
 import json
 from dataclasses import dataclass
 from typing import Any, Dict, List
-from urllib import request
+from urllib import request, error
+
+from .errors import APIError
 
 OPENAI_BASE_URL = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
@@ -39,8 +41,15 @@ def _post(path: str, payload: Dict[str, Any]) -> Dict[str, Any]:
     if OPENAI_API_KEY:
         headers["Authorization"] = f"Bearer {OPENAI_API_KEY}"
     req = request.Request(f"{OPENAI_BASE_URL}{path}", data=data, headers=headers)
-    with request.urlopen(req) as resp:
-        return json.loads(resp.read().decode())
+    try:
+        with request.urlopen(req) as resp:
+            return json.loads(resp.read().decode())
+    except error.HTTPError as exc:  # pragma: no cover - network dependent
+        raise APIError(f"HTTP error {exc.code}: {exc.reason}") from exc
+    except error.URLError as exc:  # pragma: no cover - network dependent
+        raise APIError(f"Connection error: {exc.reason}") from exc
+    except Exception as exc:  # pragma: no cover - fallback
+        raise APIError(str(exc)) from exc
 
 
 class _ChatCompletions:

pygent/runtime.py

@@ -54,29 +54,37 @@ class Runtime:
         caller can display what was run.
         """
         if self._use_docker and self.container is not None:
-            res = self.container.exec_run(
+            try:
+                res = self.container.exec_run(
+                    cmd,
+                    workdir="/workspace",
+                    demux=True,
+                    tty=False,
+                    stdin=False,
+                    timeout=timeout,
+                )
+                stdout, stderr = (
+                    res.output if isinstance(res.output, tuple) else (res.output, b"")
+                )
+                output = (stdout or b"").decode() + (stderr or b"").decode()
+                return f"$ {cmd}\n{output}"
+            except Exception as exc:
+                return f"$ {cmd}\n[error] {exc}"
+        try:
+            proc = subprocess.run(
                 cmd,
-                workdir="/workspace",
-                demux=True,
-                tty=False,
-                stdin=False,
+                shell=True,
+                cwd=self.base_dir,
+                capture_output=True,
+                text=True,
+                stdin=subprocess.DEVNULL,
                 timeout=timeout,
             )
-            stdout, stderr = (
-                res.output if isinstance(res.output, tuple) else (res.output, b"")
-            )
-            output = (stdout or b"").decode() + (stderr or b"").decode()
-            return f"$ {cmd}\n{output}"
-        proc = subprocess.run(
-            cmd,
-            shell=True,
-            cwd=self.base_dir,
-            capture_output=True,
-            text=True,
-            stdin=subprocess.DEVNULL,
-            timeout=timeout,
-        )
-        return f"$ {cmd}\n{proc.stdout + proc.stderr}"
+            return f"$ {cmd}\n{proc.stdout + proc.stderr}"
+        except subprocess.TimeoutExpired:
+            return f"$ {cmd}\n[timeout after {timeout}s]"
+        except Exception as exc:
+            return f"$ {cmd}\n[error] {exc}"
 
     def write_file(self, path: Union[str, Path], content: str) -> str:
         p = self.base_dir / path

pygent/tools.py

@@ -1,60 +1,99 @@
-"""Map of tools available to the agent."""
+"""Tool registry and helper utilities."""
 from __future__ import annotations
+
 import json
-from typing import Any, Dict
+from typing import Any, Callable, Dict, List
 
 from .runtime import Runtime
 
-TOOL_SCHEMAS = [
-    {
-        "type": "function",
-        "function": {
-            "name": "bash",
-            "description": "Run a shell command inside the sandboxed container.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "cmd": {"type": "string", "description": "Command to execute"}
-                },
-                "required": ["cmd"],
-            },
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "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"],
+
+# ---- 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,
             },
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "stop",
-            "description": "Stop the autonomous loop.",
-            "parameters": {"type": "object", "properties": {}},
-        },
-    },
-]
+        }
+    )
+
+
+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
 
-# --------------- dispatcher ---------------
 
-def execute_tool(call: Any, rt: Runtime) -> str:  # pragma: no cover, Any→openai.types.ToolCall
+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."
 
-    if name == "bash":
-        return rt.bash(**args)
-    if name == "write_file":
-        return rt.write_file(**args)
-    if name == "stop":
-        return "Stopping."
-    return f"⚠️ unknown tool {name}"

{pygent-0.1.10.dist-info → pygent-0.1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygent
-Version: 0.1.10
+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

pygent-0.1.12.dist-info/RECORD

@@ -0,0 +1,17 @@
+pygent/__init__.py,sha256=L4IRxHYfzucHUjSMvYHG-1uoTe6XaYJkaHLXuGs4CI8,648
+pygent/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+pygent/agent.py,sha256=ZyY9dEvB6bnM1ZFLh4XKQJ68v8xpRlP3HM2RRm6Y6Q0,3030
+pygent/cli.py,sha256=Hz2FZeNMVhxoT5DjCqphXla3TisGJtPEz921LEcpxrA,527
+pygent/errors.py,sha256=s5FBg_v94coSgMh7cfkP4hVXafViGYgCY8QiT698-c4,155
+pygent/models.py,sha256=j3670gjUtvQRGZ5wqGDcQ7ZJVTdT5WiwL7nWTokeYzg,1141
+pygent/openai_compat.py,sha256=cyWFtXt6sDfOlsZd3FuRxbcZMm3WU-DLPBQpbmcuiW8,2617
+pygent/py.typed,sha256=0Wh72UpGSn4lSGW-u3xMV9kxcBHMdwE15IGUqiJTwqo,52
+pygent/runtime.py,sha256=xD77DPFUfmbAwsIA5SjlEmj_TimFtN3j-6h53aUVdF0,3821
+pygent/tools.py,sha256=H2oice1Dyl-rw6Rq9hgWxpGSlxDD3ylCpxha8-4dkZQ,2568
+pygent/ui.py,sha256=xqPAvweghPOBBvoD72HzhN6zlXew_3inb8AN7Ck2zpQ,1328
+pygent-0.1.12.dist-info/licenses/LICENSE,sha256=rIktBU2VR4kHzsWul64cbom2zHIgGqYmABoZwSur6T8,1071
+pygent-0.1.12.dist-info/METADATA,sha256=896zkz6xObtzwzVoM77ts8BYMgx-lNQzuUCe8YkBv74,878
+pygent-0.1.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pygent-0.1.12.dist-info/entry_points.txt,sha256=b9j216E5UpuMrQWRZrwyEmacNEAYvw1tCKkZqdIVIOc,70
+pygent-0.1.12.dist-info/top_level.txt,sha256=P26IYsb-ThK5IkGP_bRuGJQ0Q_Y8JCcbYqVpvULdxDw,7
+pygent-0.1.12.dist-info/RECORD,,

pygent-0.1.10.dist-info/RECORD

@@ -1,16 +0,0 @@
-pygent/__init__.py,sha256=_YO8FYMUMAWlRYCa6OBsfmJ9P4mCiYoOqFBLrQDP8qQ,442
-pygent/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
-pygent/agent.py,sha256=vmTNM1SOCR8e3CV4zBT9Uyzj3LdDglZekaYupjlpl0I,2487
-pygent/cli.py,sha256=Hz2FZeNMVhxoT5DjCqphXla3TisGJtPEz921LEcpxrA,527
-pygent/models.py,sha256=_3Y1Z5wL6FUqzC-EOjZe3Vkcq4SzbPdGz6TbshcEB98,992
-pygent/openai_compat.py,sha256=mS6ntl70jpVH3JzfNYEDhg-z7QIQcMqQTuEV5ja7VOo,2173
-pygent/py.typed,sha256=0Wh72UpGSn4lSGW-u3xMV9kxcBHMdwE15IGUqiJTwqo,52
-pygent/runtime.py,sha256=hlFnqtsex8HFy3ndz9dI4cypaxH8vMW7y09OK0j4YmI,3435
-pygent/tools.py,sha256=8-jvqYeiJOlZ2ku1MTnBnK2O1m90hkrboq9aZrMORr0,1732
-pygent/ui.py,sha256=xqPAvweghPOBBvoD72HzhN6zlXew_3inb8AN7Ck2zpQ,1328
-pygent-0.1.10.dist-info/licenses/LICENSE,sha256=rIktBU2VR4kHzsWul64cbom2zHIgGqYmABoZwSur6T8,1071
-pygent-0.1.10.dist-info/METADATA,sha256=BqILS0kmRlGPSEJF2BKFwTAHBbEkcLCoQhxeLDAFgoQ,878
-pygent-0.1.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pygent-0.1.10.dist-info/entry_points.txt,sha256=b9j216E5UpuMrQWRZrwyEmacNEAYvw1tCKkZqdIVIOc,70
-pygent-0.1.10.dist-info/top_level.txt,sha256=P26IYsb-ThK5IkGP_bRuGJQ0Q_Y8JCcbYqVpvULdxDw,7
-pygent-0.1.10.dist-info/RECORD,,