python-agent-harness 1.5.4.8__tar.gz → 1.5.5.0__tar.gz

{python_agent_harness-1.5.4.8/python_agent_harness.egg-info → python_agent_harness-1.5.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.4.8
+Version: 1.5.5.0
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author: huming
 License-Expression: MIT
@@ -91,9 +91,9 @@ Edit `~/.config/python-agent-harness/config.json` and set your `base_url`, `api_
 
 ## Features
 
-- **FSM-driven execution** — explicit `WAIT` / `TOOL` / `TRET` / `SUPERVISE` / `DONE` / `ERRS` / `ABRT` states. Completion supervision nudges the model when it stops early, while failed tool calls are sanitized so they never strand the agent. Transient API failures (`429` / `5xx`) retry with exponential backoff and jitter.
+- **FSM-driven execution** — explicit `WAIT` / `TOOL` / `TRET` / `SUPERVISE` / `DONE` / `ERRS` / `ABRT` states. Completion supervision nudges the model when it stops early, while failed tool calls are sanitized so they never strand the agent. Transient API failures (`429` / `5xx`) retry with exponential backoff and jitter. Auth-expired status codes (configurable via `AUTH_REFRESH_STATUS_CODES` in `config.py`; defaults to `[401, 502]`) trigger automatic API key re-read from config/env — some API gateways return `502` instead of `401` when the backend auth token has expired. Note: codes in this list are treated as auth-expired exclusively and will not be retried with backoff, so only include codes that are unambiguously auth-related in your environment.
 - **Context management** — CJK-aware token estimation, per-model context windows, and automatic compaction at 70% usage.
-- **Coding tools** — `Agent`, `TodoWrite`, `Glob`, `Grep`, `Read`, `Insert`, `Edit` (including unified diffs), `Write`, `Mkdir`, `Bash`, `Skill`, `Question`, and `PlanExit`. Synchronous tools execute sequentially; asynchronous tools such as `Bash` and `Agent` can run concurrently while preserving emitted order.
+- **Coding tools** — `Agent`, `TodoWrite`, `Glob`, `Grep`, `Read`, `Insert`, `Edit` (including unified diffs), `Write`, `Mkdir`, `Bash`, `Skill`, `Question`, and `PlanExit`. Synchronous tools execute sequentially, but a round made up entirely of read-only tools (`Read`, `Glob`, `Grep`, `Skill`) is dispatched concurrently via a bounded thread pool; asynchronous tools such as `Bash` and `Agent` can run concurrently as well. Results are always delivered in the model's emitted order.
 - **Plan / Build modes** — plan mode is read-only except for the per-session plan file.
 - **Persistent sessions** — sessions are automatically saved after every response to `~/.local/share/python-agent-harness/sessions/`, with LLM-generated titles and support for `/restore --latest` and `/sessions`.
 - **Focused TUI** — a Rich-based interface with a pinned status bar, Todos panel, inline red/green diff rendering for `Edit` and `Write`, and a `prompt_toolkit` editor with history and completion. `Esc+Enter` submits, `Ctrl-D` quits, and `Ctrl-C` cancels without leaving the application.

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/README.md

@@ -68,9 +68,9 @@ Edit `~/.config/python-agent-harness/config.json` and set your `base_url`, `api_
 
 ## Features
 
-- **FSM-driven execution** — explicit `WAIT` / `TOOL` / `TRET` / `SUPERVISE` / `DONE` / `ERRS` / `ABRT` states. Completion supervision nudges the model when it stops early, while failed tool calls are sanitized so they never strand the agent. Transient API failures (`429` / `5xx`) retry with exponential backoff and jitter.
+- **FSM-driven execution** — explicit `WAIT` / `TOOL` / `TRET` / `SUPERVISE` / `DONE` / `ERRS` / `ABRT` states. Completion supervision nudges the model when it stops early, while failed tool calls are sanitized so they never strand the agent. Transient API failures (`429` / `5xx`) retry with exponential backoff and jitter. Auth-expired status codes (configurable via `AUTH_REFRESH_STATUS_CODES` in `config.py`; defaults to `[401, 502]`) trigger automatic API key re-read from config/env — some API gateways return `502` instead of `401` when the backend auth token has expired. Note: codes in this list are treated as auth-expired exclusively and will not be retried with backoff, so only include codes that are unambiguously auth-related in your environment.
 - **Context management** — CJK-aware token estimation, per-model context windows, and automatic compaction at 70% usage.
-- **Coding tools** — `Agent`, `TodoWrite`, `Glob`, `Grep`, `Read`, `Insert`, `Edit` (including unified diffs), `Write`, `Mkdir`, `Bash`, `Skill`, `Question`, and `PlanExit`. Synchronous tools execute sequentially; asynchronous tools such as `Bash` and `Agent` can run concurrently while preserving emitted order.
+- **Coding tools** — `Agent`, `TodoWrite`, `Glob`, `Grep`, `Read`, `Insert`, `Edit` (including unified diffs), `Write`, `Mkdir`, `Bash`, `Skill`, `Question`, and `PlanExit`. Synchronous tools execute sequentially, but a round made up entirely of read-only tools (`Read`, `Glob`, `Grep`, `Skill`) is dispatched concurrently via a bounded thread pool; asynchronous tools such as `Bash` and `Agent` can run concurrently as well. Results are always delivered in the model's emitted order.
 - **Plan / Build modes** — plan mode is read-only except for the per-session plan file.
 - **Persistent sessions** — sessions are automatically saved after every response to `~/.local/share/python-agent-harness/sessions/`, with LLM-generated titles and support for `/restore --latest` and `/sessions`.
 - **Focused TUI** — a Rich-based interface with a pinned status bar, Todos panel, inline red/green diff rendering for `Edit` and `Write`, and a `prompt_toolkit` editor with history and completion. `Esc+Enter` submits, `Ctrl-D` quits, and `Ctrl-C` cancels without leaving the application.

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-agent-harness"
-version = "1.5.4.8"
+version = "1.5.5.0"
 description = "A lightweight, hackable mini-OpenCode written in Python."
 readme = "README.md"
 requires-python = ">=3.11"

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/python_agent_harness/__init__.py

@@ -5,7 +5,7 @@ from .mcp.manager import MCPManager
 from .models import AgentMode, Message, ToolCall, ToolSpec
 from .session import Session
 
-__version__ = "1.5.4.8"
+__version__ = "1.5.5.0"
 
 __all__ = [
     "Session",

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/python_agent_harness/client.py

@@ -12,6 +12,7 @@ import json
 import os
 import random
 import socket as _socket
+import sys
 import threading
 import time
 import uuid
@@ -48,9 +49,12 @@ class RetryableApiError(ApiError):
 
 
 class AuthExpiredError(ApiError):
-    """Raised on HTTP 401 — the credential may have expired.
+    """Raised on auth-expired HTTP status codes.
 
-    Handled specially in the retry loop: the API key is re-read from
+    By default HTTP 401, but customizable via
+    ``config.AUTH_REFRESH_STATUS_CODES`` — some API gateways return 502
+    or other codes when the backend auth token has expired.  Handled
+    specially in the retry loop: the API key is re-read from
     config/environment (an external process may have refreshed the
     token) and the request is retried once with the new key.  If the
     key hasn't changed, the error is permanent and propagated as a
@@ -59,7 +63,13 @@ class AuthExpiredError(ApiError):
 
 
 def _retryable_status(status: int) -> bool:
-    """429 and 5xx are transient; every other error is permanent."""
+    """429 and 5xx are transient; every other error is permanent.
+
+    Status codes in ``config.AUTH_REFRESH_STATUS_CODES`` are excluded —
+    they are handled as auth-expired, not retried with backoff.
+    """
+    if status in config.AUTH_REFRESH_STATUS_CODES:
+        return False
     return status == 429 or status >= 500
 
 
@@ -507,12 +517,14 @@ class Client:
                 if self._sleep_backoff(attempt, e.retry_after, cancel_check):
                     raise
             except AuthExpiredError as e:
-                # HTTP 401: the credential (often a JWT with a short
-                # TTL) may have expired.  Re-read the API key from the
-                # config file / environment — an external token-refresh
-                # process may have written a new one.  Poll for up to
-                # 30s waiting for the key to change; retry once if it
-                # does.  Fail immediately if already refreshed once
+                # Auth-expired status code (401, or any code in
+                # config.AUTH_REFRESH_STATUS_CODES): the credential
+                # (often a JWT with a short TTL) may have expired.
+                # Re-read the API key from the config file / environment
+                # — an external token-refresh process may have written a
+                # new one.  Poll for up to 30s waiting for the key to
+                # change; retry once if it does.  Fail immediately if
+                # already refreshed once
                 # (prevents infinite loops).
                 self._reset_http()
                 if auth_refreshed or not self._refresh_api_key(cancel_check):
@@ -634,7 +646,7 @@ class Client:
             if resp.status_code >= 400:
                 body = resp.read().decode("utf-8", "replace")
                 message = f"API error {resp.status_code}: {body[:500]}"
-                if resp.status_code == 401:
+                if resp.status_code in config.AUTH_REFRESH_STATUS_CODES:
                     raise AuthExpiredError(message)
                 if _retryable_status(resp.status_code):
                     raise RetryableApiError(message, resp.headers.get("Retry-After"))
@@ -696,7 +708,7 @@ class Client:
         resp = self._http.post(self._url(), headers=self._headers(stream=False), json=payload)
         if resp.status_code >= 400:
             message = f"API error {resp.status_code}: {resp.text[:500]}"
-            if resp.status_code == 401:
+            if resp.status_code in config.AUTH_REFRESH_STATUS_CODES:
                 raise AuthExpiredError(message)
             if _retryable_status(resp.status_code):
                 raise RetryableApiError(message, resp.headers.get("Retry-After"))
@@ -822,6 +834,47 @@ def _default_api_key() -> str | None:
     return os.environ.get("OPENAI_API_KEY") or os.environ.get("DEEPSEEK_API_KEY") or None
 
 
+def _extract_socket(conn: object) -> _socket.socket | None:
+    """Best-effort extraction of the raw socket from an httpcore connection.
+
+    For direct (non-proxy) connections the socket lives at
+    ``conn._connection._network_stream``.  Proxy connections are wrapped
+    (ForwardHTTPConnection/TunnelHTTPConnection -> HTTPConnection ->
+    HTTP11Connection), so we unwrap up to 4 levels looking for the
+    ``_network_stream`` attribute that owns the raw socket.
+    """
+    try:
+        obj: object = conn
+        stream = None
+        for _ in range(4):
+            stream = getattr(obj, "_network_stream", None)
+            if stream is not None:
+                break
+            obj = getattr(obj, "_connection", None)
+            if obj is None:
+                break
+        return stream.get_extra_info("socket") if stream is not None else None
+    except Exception:  # noqa: BLE001 - best effort
+        return None
+
+
+def _shutdown_and_close(sock: _socket.socket) -> None:
+    """Shutdown then close a socket to wake blocked reads.
+
+    On macOS the socket is in non-blocking mode (httpcore calls
+    settimeout for the read timeout), so a blocked recv parks in
+    select(); closing the fd before that select has processed the
+    shutdown wakeup can lose the wakeup and leave the read parked
+    forever.  Give the woken thread a moment to observe the EOF first.
+    """
+    with contextlib.suppress(OSError):
+        sock.shutdown(_socket.SHUT_RDWR)
+    if sys.platform == "darwin":
+        time.sleep(0.05)
+    with contextlib.suppress(OSError):
+        sock.close()
+
+
 def _abort_inflight_sockets(client: httpx.Client) -> None:
     """Wake any blocked stream reads on every live pool socket.
 
@@ -849,21 +902,31 @@ def _abort_inflight_sockets(client: httpx.Client) -> None:
     ``contextlib.suppress`` right after this call, so a double-close is
     harmless.  Every step is best-effort; any failure is ignored.
     """
-    pool = getattr(getattr(client, "_transport", None), "_pool", None)
-    for conn in getattr(pool, "_connections", None) or ():
-        try:
-            stream = getattr(getattr(conn, "_connection", None), "_network_stream", None)
-            sock = stream.get_extra_info("socket") if stream is not None else None
-        except Exception:  # noqa: BLE001 - best effort
-            sock = None
-        if sock is not None:
-            # shutdown first (wakes the recv on Linux without touching
-            # the fd), then close the fd (the reliable wake on
-            # macOS/BSD, where shutdown alone may not).
-            with contextlib.suppress(OSError):
-                sock.shutdown(_socket.SHUT_RDWR)
-            with contextlib.suppress(OSError):
-                sock.close()
+    pools: list[object] = []
+    base_pool = getattr(getattr(client, "_transport", None), "_pool", None)
+    if base_pool is not None:
+        pools.append(base_pool)
+
+    if sys.platform == "darwin":
+        # macOS only: with proxy env vars (HTTP_PROXY/HTTPS_PROXY) set,
+        # httpx routes requests through proxy transports registered in
+        # client._mounts (pools are httpcore.HTTPProxy), leaving the
+        # base transport pool above empty.  On Linux this never happens
+        # in CI and the code path above is sufficient, so this extra
+        # walk is deliberately restricted to macOS.
+        mounts = getattr(client, "_mounts", None)
+        if isinstance(mounts, dict):
+            for transport in mounts.values():
+                if transport is not None:
+                    pool = getattr(transport, "_pool", None)
+                    if pool is not None:
+                        pools.append(pool)
+
+    for pool in pools:
+        for conn in getattr(pool, "_connections", None) or ():
+            sock = _extract_socket(conn)
+            if sock is not None:
+                _shutdown_and_close(sock)
 
 
 def _iter_sse(lines: Iterator[str]) -> Iterator[str]:

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/python_agent_harness/config.py

@@ -1,7 +1,4 @@
-"""Configuration defaults for python-agent-harness.
-
-Mirrors the defcustom defaults of the Emacs gptel-agent-harness.
-"""
+"""Configuration defaults for python-agent-harness."""
 
 from __future__ import annotations
 
@@ -131,6 +128,14 @@ API_RETRY_MAX = 3  # max attempts per request (initial + retries)
 API_RETRY_BASE_DELAY = 1.0  # base backoff (seconds), doubled per attempt
 API_RETRY_MAX_DELAY = 30.0  # per-attempt backoff cap (seconds)
 
+# HTTP status codes that should trigger auth-refresh (key re-read from
+# config/env) instead of being treated as transient retryable errors.
+# 401 is always included (standard "Unauthorized").  Some API gateways
+# return 502 or other 5xx codes when the backend auth token has expired
+# rather than a proper 401 — add those here so the client refreshes the
+# key instead of pointlessly retrying the same expired credential.
+AUTH_REFRESH_STATUS_CODES: list[int] = [401, 502]
+
 # ---- tool execution ----------------------------------------------------------
 SUBAGENT_MAX_ROUNDS = 60
 # Tool execution mirrors gptel's `gptel--handle-tool-use': synchronous

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/python_agent_harness/session.py

@@ -156,6 +156,11 @@ class Session:
         # active clones are tracked so cancel()/close() can reach them.
         self._subagent_clients_lock = threading.Lock()
         self._active_subagent_clients: list[Client] = []
+        # guards _skill_index_cache: parallel readonly tool threads
+        # (e.g. multiple Skill calls in one round) can hit the lazy
+        # cache build simultaneously — double-checked locking prevents
+        # redundant filesystem scans and the data race on the cache tuple
+        self._skill_index_lock = threading.Lock()
         self.store = SessionPersistence(
             project_dir=project_dir,
             model=model,
@@ -377,10 +382,18 @@ class Session:
         return hit[0] if hit else None
 
     def _skill_index(self) -> dict[str, tuple[str, str]]:
-        """Return the cached name -> (path, description) skill index."""
+        """Return the cached name -> (path, description) skill index.
+
+        Thread-safe via double-checked locking: parallel readonly tool
+        threads (e.g. multiple Skill calls in one round) can reach the
+        lazy cache build simultaneously — the lock ensures only one
+        thread scans the filesystem and writes the cache tuple.
+        """
         key = self._skill_dir
         if self._skill_index_cache is None or self._skill_index_cache[0] != key:
-            self._skill_index_cache = (key, index_skills(key))
+            with self._skill_index_lock:
+                if self._skill_index_cache is None or self._skill_index_cache[0] != key:
+                    self._skill_index_cache = (key, index_skills(key))
         return self._skill_index_cache[1]
 
     def _find_skill_dir(self) -> str | None:

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/python_agent_harness/tool_runner.py

@@ -6,12 +6,20 @@ state (``messages`` / ``pending`` / ``info``) through the loop
 reference.  Tool calls are always executed and delivered via the
 loop's ``_execute_tool_call`` / ``_deliver_tool_result`` methods so
 subclass or test overrides of those methods keep working.
+
+When every call in a round is readonly (``Tool.is_readonly = True``),
+the round is dispatched concurrently via a thread pool: readonly tools
+only read state, so none can depend on another's side effects, and
+running them in parallel reduces latency for read-heavy rounds (e.g.
+the model reading several files at once).  Mixed rounds (any
+non-readonly tool) fall back to the original sequential dispatch.
 """
 
 from __future__ import annotations
 
 import json
 import time
+from concurrent.futures import ThreadPoolExecutor
 from typing import Any
 
 from . import config
@@ -22,6 +30,13 @@ NIL_RESULT_PLACEHOLDER = (
     "Error: tool produced no result (it may have been interrupted or failed to return)."
 )
 
+# Upper bound on threads spawned for a parallel readonly round.  The
+# round size is driven by model output (a single response can emit
+# dozens of Read/Grep calls), so cap peak concurrency to avoid a
+# thread explosion; the pool still drains every call, just fewer at a
+# time.
+MAX_PARALLEL_READONLY = 8
+
 
 def sanitize_tool_result(result: object) -> str:
     """Sanitize a tool result for the model.
@@ -106,12 +121,22 @@ class ToolRunner:
         afterwards, again in original call order.  Delivery happens
         later, in original tool-call order, by the caller.
 
+        When every call in the round is readonly (``Tool.is_readonly``),
+        the round is dispatched concurrently via a thread pool:
+        readonly tools only read state, so none can depend on
+        another's side effects, and running them in parallel reduces
+        latency for read-heavy rounds (e.g. the model reading several
+        files at once).  Mixed rounds fall back to sequential dispatch.
+
         A cancel landing before a call starts skips it (tools have side
         effects); a call already running — or an async tool already
         dispatched — cannot be stopped, but its result stays local to
         the (dead) run.
         """
         loop = self.loop
+        if calls and self._all_readonly(calls):
+            self._run_parallel(calls, results)
+            return
         async_calls: list[tuple[ToolCall, PendingToolResult]] = []
         for p in calls:
             # A cancel landing while a call is still QUEUED must skip
@@ -151,6 +176,63 @@ class ToolRunner:
                 p.elapsed = time.monotonic() - start
                 results[p.id] = sanitize_tool_result(result)
 
+    def _all_readonly(self, calls: list[ToolCall]) -> bool:
+        """True when every call's tool is marked ``is_readonly``."""
+        loop = self.loop
+        for p in calls:
+            tool = loop.session.registry.get(p.name)
+            if tool is None or not tool.is_readonly:
+                return False
+        return True
+
+    def _run_parallel(self, calls: list[ToolCall], results: dict[str, str]) -> None:
+        """Dispatch all calls concurrently via a thread pool.
+
+        Used only when every call is readonly.  Each tool runs in its
+        own thread; results are collected in original call order.
+        Cancel is checked before dispatching (a call that has not
+        started yet is skipped); a call already running cannot be
+        stopped, but its result stays local to the (dead) run.
+        """
+        loop = self.loop
+        futures: dict[str, Any] = {}
+        with ThreadPoolExecutor(max_workers=min(len(calls), MAX_PARALLEL_READONLY)) as pool:
+            for p in calls:
+                if loop._is_cancelled():
+                    results[p.id] = "Error: tool call cancelled (user aborted the run)."
+                    continue
+                if loop.top_level:
+                    loop.session.notify("tool_running", p.name)
+                futures[p.id] = pool.submit(self._exec_one, p)
+            for p in calls:
+                fut = futures.get(p.id)
+                if fut is None:
+                    continue
+                try:
+                    result = fut.result()
+                except Exception as e:  # noqa: BLE001 - containment boundary
+                    results[p.id] = f"Error: tool {p.name!r} crashed during execution — {e}"
+                else:
+                    if isinstance(result, PendingToolResult):
+                        result = result.wait()
+                    results[p.id] = sanitize_tool_result(result)
+
+    def _exec_one(self, p: ToolCall) -> str | PendingToolResult:
+        """Execute one tool call and return its raw result.
+
+        Thin wrapper around ``loop._execute_tool_call`` that records
+        elapsed time on the call object.  Used by ``_run_parallel``.
+        """
+        loop = self.loop
+        start = time.monotonic()
+        try:
+            result = loop._execute_tool_call(p)
+        except Exception as e:  # noqa: BLE001 - containment boundary
+            p.elapsed = time.monotonic() - start
+            return f"Error: tool {p.name!r} crashed during execution — {e}"
+        p.elapsed = time.monotonic() - start
+        return result
+
     def execute_pending(self) -> None:
         """TOOL state: run the round's pending tool calls.
 

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/python_agent_harness/tools/base.py

@@ -91,6 +91,11 @@ class ToolContext:
 class Tool(ABC):
     name: str = ""
     description: str = ""
+    # True for tools that only read state (Read, Glob, Grep, Skill):
+    # when EVERY call in a round is readonly, the runner dispatches
+    # them concurrently via a thread pool instead of one-at-a-time,
+    # since none can depend on another's side effects.
+    is_readonly: bool = False
     # NB: Tool is an ABC, not a dataclass, so this is a plain class-level
     # default (never mutated in place — every concrete tool overrides it
     # with its own schema).  It must be a real dict: a dataclasses.field()

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/python_agent_harness/tools/filesystem.py

@@ -35,6 +35,7 @@ import os
 import shutil  # noqa: F401  (mock target for tests)
 import subprocess  # noqa: F401  (mock target for tests)
 import tempfile
+import threading
 import time
 from pathlib import Path
 from typing import TypeGuard
@@ -47,6 +48,8 @@ READ_SIZE_LIMIT = 400 * 1024  # whole-file reads above this are refused
 
 _spooled_files: list[str] = []  # temp files created by _spool, cleaned
 # up by cleanup_spooled_files on session close
+_spooled_files_lock = threading.Lock()  # guards _spooled_files across
+# parallel readonly tool threads (Glob/Grep/Read can _spool concurrently)
 
 
 def _truncate(text: str, label: str = "output") -> str:
@@ -89,7 +92,8 @@ def _spool(text: str, label: str) -> str:
         )
         with os.fdopen(fd, "w", encoding="utf-8") as f:
             f.write(text)
-        _spooled_files.append(temp_file)
+        with _spooled_files_lock:
+            _spooled_files.append(temp_file)
     except OSError:
         return _truncate(text, label)
     lines = text.splitlines()
@@ -112,8 +116,9 @@ def cleanup_spooled_files() -> None:
     in the temp dir.  Files already removed (e.g. by a restored
     session) are skipped.
     """
-    paths = _spooled_files[:]
-    _spooled_files.clear()
+    with _spooled_files_lock:
+        paths = _spooled_files[:]
+        _spooled_files.clear()
     for path in paths:
         try:
             if os.path.exists(path):
@@ -179,6 +184,7 @@ __all__ = [
     "_spool",
     "_spool_dir",
     "_spooled_files",
+    "_spooled_files_lock",
     "_strip_diff_fence",
     "_truncate",
 ]

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/python_agent_harness/tools/glob.py

@@ -19,6 +19,7 @@ from .filesystem import _git_root, _natnump, _spool
 
 class GlobTool(Tool):
     name = "Glob"
+    is_readonly = True
     description = (
         "Recursively find files matching a provided glob pattern.\n\n"
         '- Supports glob patterns like "*.md" or "*test*.py".\n'

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/python_agent_harness/tools/grep.py

@@ -18,6 +18,7 @@ from .filesystem import _git_root, _spool
 
 class Grep(Tool):
     name = "Grep"
+    is_readonly = True
     description = (
         "Search file contents with a regular expression. "
         "Use this for content search; use Glob for filename search. "

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/python_agent_harness/tools/read.py

@@ -18,6 +18,7 @@ from .filesystem import READ_SIZE_LIMIT, _spool
 
 class Read(Tool):
     name = "Read"
+    is_readonly = True
     description = (
         "Read file contents between specified line numbers `start_line` and "
         "`end_line`, with both ends included.\n\n"

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/python_agent_harness/tools/skill.py

@@ -9,6 +9,7 @@ from .base import Tool, ToolContext
 
 class Skill(Tool):
     name = "Skill"
+    is_readonly = True
     description = (
         "Load a skill to get detailed instructions for a specific task. "
         "Use this when a task matches an available skill's description. "

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/python_agent_harness/tui/core.py

@@ -101,29 +101,32 @@ class Tui(RenderMixin, InputMixin, CommandMixin):
             # (the assistant message is committed to messages and will
             # appear in history once delivered) and show which tools are
             # running, so the display stays alive during long operations.
-            with self.lock:
-                self.stream_text = ""
             names = data if isinstance(data, list) else []
             label = ", ".join(names) if names else "tools"
-            self._current_tool = label
-            self.status = f" ⏳ {label}"
-            self._history_dirty = True
+            with self.lock:
+                self.stream_text = ""
+                self._current_tool = label
+                self.status = f" ⏳ {label}"
+                self._history_dirty = True
         elif kind == "tool_running":
             # Per-tool notification: update the current tool name shown
             # beside the spinner as each sync tool starts executing.
             name = data if isinstance(data, str) else ""
-            self._current_tool = name
-            self.status = f" ⏳ {name}" if name else " ⏳ tools"
+            with self.lock:
+                self._current_tool = name
+                self.status = f" ⏳ {name}" if name else " ⏳ tools"
         elif kind == "tools":
-            self._current_tool = ""
-            self.status = " running tools"
             # tool round finished: session.last_messages now contains the
             # tool-call + result rows — rebuild the cached history so
             # they show up live instead of after the run ends
-            self._history_dirty = True
+            with self.lock:
+                self._current_tool = ""
+                self.status = " running tools"
+                self._history_dirty = True
         elif kind == "compact":
-            self.status = " compacted"
-            self._history_dirty = True
+            with self.lock:
+                self.status = " compacted"
+                self._history_dirty = True
         elif kind == "retry":
             # A connection error mid-stream: the client discarded the
             # partial response and is retrying on a fresh connection —
@@ -131,21 +134,26 @@ class Tui(RenderMixin, InputMixin, CommandMixin):
             # doesn't duplicate it on screen.
             with self.lock:
                 self.stream_text = ""
-            self.status = " connection lost — retrying"
+                self.status = " connection lost — retrying"
         elif kind == "todos":
             # TodoWrite updated the task list: the cached history rows
             # (which include the Todos panel) must be rebuilt
-            self._history_dirty = True
+            with self.lock:
+                self._history_dirty = True
         elif kind == "error":
-            self.status = " error"
+            with self.lock:
+                self.status = " error"
         elif kind == "save-error":
-            self.status = " auto-save failed"
+            with self.lock:
+                self.status = " auto-save failed"
         else:
-            self.status = " running"
+            with self.lock:
+                self.status = " running"
         self._data_event.set()
 
     def _on_log(self, msg: str) -> None:
-        self.status = f" {msg}"
+        with self.lock:
+            self.status = f" {msg}"
 
     # ------------------------------------------------------------------
     # main loop

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/python_agent_harness/tui/render.py

@@ -329,10 +329,16 @@ class RenderMixin:
         rebuild (and re-parse Markdown for) the whole conversation every
         frame — that cost is what made the scroll lag behind the text.
         """
-        if self._history_dirty or self._history_cache is None:
-            self._history_cache = self._build_history_rows()
-            self._history_dirty = False
-        return list(self._history_cache)
+        with self.lock:
+            dirty = self._history_dirty
+            cache = self._history_cache
+        if dirty or cache is None:
+            built = self._build_history_rows()
+            with self.lock:
+                self._history_cache = built
+                self._history_dirty = False
+            return list(built)
+        return list(cache)
 
     def _stream_row(self) -> Text | None:
         """Live stream row (cheap Text, tail-capped)."""
@@ -499,11 +505,19 @@ class RenderMixin:
         if self.agent_running:
             frame = SPINNER_FRAMES[int(time.time() * 10) % len(SPINNER_FRAMES)]
             t.append(f" {frame}", style="bold cyan")
-            if self._current_tool:
-                t.append(f" {self._current_tool}", style="bold cyan")
+            with self.lock:
+                tool = self._current_tool
+                status = self.status
+            if tool:
+                t.append(f" {tool}", style="bold cyan")
         elif self.question is not None:
             t.append(" ❓", style="yellow")
-        t.append(self._fit_status(cell_len(str(t)), self.status), style=self._status_style())
+            with self.lock:
+                status = self.status
+        else:
+            with self.lock:
+                status = self.status
+        t.append(self._fit_status(cell_len(str(t)), status), style=self._status_style())
         return t
 
     def _fit_status(self, used: int, msg: str) -> str:
@@ -527,7 +541,8 @@ class RenderMixin:
 
     def _status_style(self) -> str:
         """Status-bar color by state: errors red, activity cyan, idle dim."""
-        s = self.status
+        with self.lock:
+            s = self.status
         if "error" in s or "failed" in s:
             return "bold red"
         if " ⏳" in s or " running" in s or "retrying" in s:

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0/python_agent_harness.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.4.8
+Version: 1.5.5.0
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author: huming
 License-Expression: MIT
@@ -91,9 +91,9 @@ Edit `~/.config/python-agent-harness/config.json` and set your `base_url`, `api_
 
 ## Features
 
-- **FSM-driven execution** — explicit `WAIT` / `TOOL` / `TRET` / `SUPERVISE` / `DONE` / `ERRS` / `ABRT` states. Completion supervision nudges the model when it stops early, while failed tool calls are sanitized so they never strand the agent. Transient API failures (`429` / `5xx`) retry with exponential backoff and jitter.
+- **FSM-driven execution** — explicit `WAIT` / `TOOL` / `TRET` / `SUPERVISE` / `DONE` / `ERRS` / `ABRT` states. Completion supervision nudges the model when it stops early, while failed tool calls are sanitized so they never strand the agent. Transient API failures (`429` / `5xx`) retry with exponential backoff and jitter. Auth-expired status codes (configurable via `AUTH_REFRESH_STATUS_CODES` in `config.py`; defaults to `[401, 502]`) trigger automatic API key re-read from config/env — some API gateways return `502` instead of `401` when the backend auth token has expired. Note: codes in this list are treated as auth-expired exclusively and will not be retried with backoff, so only include codes that are unambiguously auth-related in your environment.
 - **Context management** — CJK-aware token estimation, per-model context windows, and automatic compaction at 70% usage.
-- **Coding tools** — `Agent`, `TodoWrite`, `Glob`, `Grep`, `Read`, `Insert`, `Edit` (including unified diffs), `Write`, `Mkdir`, `Bash`, `Skill`, `Question`, and `PlanExit`. Synchronous tools execute sequentially; asynchronous tools such as `Bash` and `Agent` can run concurrently while preserving emitted order.
+- **Coding tools** — `Agent`, `TodoWrite`, `Glob`, `Grep`, `Read`, `Insert`, `Edit` (including unified diffs), `Write`, `Mkdir`, `Bash`, `Skill`, `Question`, and `PlanExit`. Synchronous tools execute sequentially, but a round made up entirely of read-only tools (`Read`, `Glob`, `Grep`, `Skill`) is dispatched concurrently via a bounded thread pool; asynchronous tools such as `Bash` and `Agent` can run concurrently as well. Results are always delivered in the model's emitted order.
 - **Plan / Build modes** — plan mode is read-only except for the per-session plan file.
 - **Persistent sessions** — sessions are automatically saved after every response to `~/.local/share/python-agent-harness/sessions/`, with LLM-generated titles and support for `/restore --latest` and `/sessions`.
 - **Focused TUI** — a Rich-based interface with a pinned status bar, Todos panel, inline red/green diff rendering for `Edit` and `Write`, and a `prompt_toolkit` editor with history and completion. `Esc+Enter` submits, `Ctrl-D` quits, and `Ctrl-C` cancels without leaving the application.

{python_agent_harness-1.5.4.8 → python_agent_harness-1.5.5.0}/tests/test_client.py

@@ -816,6 +816,7 @@ class TestAbortInflightSockets(unittest.TestCase):
 
     def _fake_client_with_stream(self, stream):
         conn = mock.Mock()
+        conn._network_stream = None
         conn._connection._network_stream = stream
         client = mock.Mock()
         client._transport._pool._connections = [conn]
@@ -1707,6 +1708,134 @@ class TestAuthRefreshOn401(unittest.TestCase):
         c.close()
 
 
+class TestAuthRefreshOnConfigurableStatusCodes(unittest.TestCase):
+    """Status codes in config.AUTH_REFRESH_STATUS_CODES (not just 401)
+    trigger the auth-refresh path — e.g. some gateways return 502 when
+    the backend auth token has expired."""
+
+    def test_502_triggers_auth_refresh_and_retries(self):
+        """A 502 (in AUTH_REFRESH_STATUS_CODES) triggers key re-read;
+        if the key changed, the request is retried and can succeed."""
+        from python_agent_harness.client import AuthExpiredError
+
+        c = make_offline_client(retry_max=3, retry_base_delay=0.01, retry_max_delay=0.01)
+        calls = {"n": 0}
+
+        def fake_stream(payload, on_delta, on_tool_call, usage):
+            n = calls["n"]
+            calls["n"] += 1
+            if n == 0:
+                raise AuthExpiredError("API error 502: Bad Gateway")
+            return (["ok"], [], {})
+
+        with (
+            mock.patch.object(c, "_stream_response", side_effect=fake_stream),
+            mock.patch.object(c, "_refresh_api_key", return_value=True),
+        ):
+            msg, _ = c.chat([Message(role="user", content="hi")])
+
+        self.assertEqual(calls["n"], 2)
+        self.assertEqual(msg.text(), "ok")
+        c.close()
+
+    def test_502_with_unchanged_key_fails_immediately(self):
+        """A 502 where the key hasn't changed propagates as a permanent
+        ApiError (no backoff retry)."""
+        from python_agent_harness.client import ApiError, AuthExpiredError
+
+        c = make_offline_client(retry_max=3, retry_base_delay=0.01, retry_max_delay=0.01)
+        calls = {"n": 0}
+
+        def fake_stream(payload, on_delta, on_tool_call, usage):
+            calls["n"] += 1
+            raise AuthExpiredError("API error 502: Bad Gateway")
+
+        with (
+            mock.patch.object(c, "_stream_response", side_effect=fake_stream),
+            mock.patch.object(c, "_refresh_api_key", return_value=False),
+            self.assertRaises(ApiError) as ctx,
+        ):
+            c.chat([Message(role="user", content="hi")])
+
+        self.assertEqual(calls["n"], 1)
+        self.assertIn("502", str(ctx.exception))
+        c.close()
+
+    def test_custom_status_code_triggers_auth_refresh(self):
+        """A custom status code added to AUTH_REFRESH_STATUS_CODES
+        triggers auth refresh instead of retryable backoff."""
+        from python_agent_harness.client import AuthExpiredError
+
+        c = make_offline_client(retry_max=3, retry_base_delay=0.01, retry_max_delay=0.01)
+        calls = {"n": 0}
+
+        def fake_stream(payload, on_delta, on_tool_call, usage):
+            n = calls["n"]
+            calls["n"] += 1
+            if n == 0:
+                raise AuthExpiredError("API error 419: Token Expired")
+            return (["ok"], [], {})
+
+        with (
+            mock.patch("python_agent_harness.config.AUTH_REFRESH_STATUS_CODES", [401, 419]),
+            mock.patch.object(c, "_stream_response", side_effect=fake_stream),
+            mock.patch.object(c, "_refresh_api_key", return_value=True),
+        ):
+            msg, _ = c.chat([Message(role="user", content="hi")])
+
+        self.assertEqual(calls["n"], 2)
+        self.assertEqual(msg.text(), "ok")
+        c.close()
+
+    def test_503_not_in_auth_refresh_still_retryable(self):
+        """A 503 (not in AUTH_REFRESH_STATUS_CODES by default) is still
+        treated as a retryable error, not an auth-refresh error."""
+        from python_agent_harness.client import ApiError, RetryableApiError
+
+        c = make_offline_client(retry_max=2, retry_base_delay=0.01, retry_max_delay=0.01)
+        calls = {"n": 0}
+
+        def fake_stream(payload, on_delta, on_tool_call, usage):
+            calls["n"] += 1
+            raise RetryableApiError("API error 503: Service Unavailable")
+
+        with (
+            mock.patch.object(c, "_stream_response", side_effect=fake_stream),
+            mock.patch.object(c, "_refresh_api_key") as refresh_mock,
+            self.assertRaises(ApiError),
+        ):
+            c.chat([Message(role="user", content="hi")])
+
+        # retried up to retry_max, never triggered auth refresh
+        self.assertEqual(calls["n"], 2)
+        refresh_mock.assert_not_called()
+        c.close()
+
+    def test_502_on_sync_request_also_triggers_refresh(self):
+        """Non-streaming requests also benefit from 502 auth refresh."""
+        from python_agent_harness.client import AuthExpiredError
+
+        c = make_offline_client(retry_max=3, retry_base_delay=0.01, retry_max_delay=0.01)
+        calls = {"n": 0}
+
+        def fake_sync(payload, on_delta, on_tool_call, usage):
+            n = calls["n"]
+            calls["n"] += 1
+            if n == 0:
+                raise AuthExpiredError("API error 502: Bad Gateway")
+            return (["title"], [], {})
+
+        with (
+            mock.patch.object(c, "_sync_response", side_effect=fake_sync),
+            mock.patch.object(c, "_refresh_api_key", return_value=True),
+        ):
+            msg, _ = c.chat_sync([Message(role="user", content="hi")])
+
+        self.assertEqual(calls["n"], 2)
+        self.assertEqual(msg.text(), "title")
+        c.close()
+
+
 class TestContextWindow(unittest.TestCase):
     """Client.context_window: config-file overrides -> CONTEXT_WINDOWS
     patterns -> DEFAULT_CONTEXT_WINDOW.  Resolved on every access (no