python-agent-harness 1.5.6.5__tar.gz → 1.5.6.7__tar.gz

{python_agent_harness-1.5.6.5/python_agent_harness.egg-info → python_agent_harness-1.5.6.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.6.5
+Version: 1.5.6.7
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author-email: Huming Chen <chenhuming@gmail.com>
 License-Expression: MIT

{python_agent_harness-1.5.6.5 → python_agent_harness-1.5.6.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-agent-harness"
-version = "1.5.6.5"
+version = "1.5.6.7"
 description = "A lightweight, hackable mini-OpenCode written in Python."
 authors = [
     {name = "Huming Chen", email = "chenhuming@gmail.com"}

{python_agent_harness-1.5.6.5 → python_agent_harness-1.5.6.7}/python_agent_harness/__init__.py

@@ -7,7 +7,7 @@ from .mcp.config import MCPConfig, MCPServerConfig
 from .mcp.manager import MCPManager
 from .session.session import Session
 
-__version__ = "1.5.6.5"
+__version__ = "1.5.6.7"
 
 __all__ = [
     "Client",

{python_agent_harness-1.5.6.5 → python_agent_harness-1.5.6.7}/python_agent_harness/core/context_manager.py

@@ -65,10 +65,11 @@ class ContextManager:
     def compact(self) -> bool:
         """Compact the conversation; return True on success.
 
-        On success the history is replaced by the summary frame followed
-        by every real user prompt (nudges and other harness-injected
-        messages excluded), so the model keeps the actual requests; the
-        last prompt is the resume request for the next round.
+        On success the history is replaced by the summary frame, every
+        real user prompt (nudges and other harness-injected messages
+        excluded), and a trailing resume message telling the model what
+        is already done — the summary and the prompts alone end on a
+        bare user request, which invites redoing finished work.
         """
         loop = self.loop
         prompts = user_prompt_texts(loop.messages)
@@ -87,8 +88,10 @@ class ContextManager:
             # stays untouched): it is part of the user turn, never a
             # system message.  Every real user prompt (nudges and other
             # harness-injected messages excluded) is preserved verbatim
-            # after the frame, so the model keeps the actual requests.
-            loop.messages = compacted_messages(summary, prompts)
+            # after the frame, so the model keeps the actual requests,
+            # and the trailing resume message states that the summarised
+            # work is done (injected flag: TUI and filters skip it).
+            loop.messages = compacted_messages(summary, prompts, resume=True)
             # The shared conversation now is the compacted one: mirror it
             # onto session.last_messages so the TUI (renders from it) and
             # a later manual /compact start from the summary, not the old

{python_agent_harness-1.5.6.5 → python_agent_harness-1.5.6.7}/python_agent_harness/core/models.py

@@ -35,6 +35,23 @@ class AgentMode(enum.Enum):
     PLAN = "plan"
 
 
+def extract_reasoning(obj: dict[str, Any]) -> str:
+    """Reasoning text from a backend response object, or "".
+
+    Backends disagree on the field name: most (DeepSeek, GLM, ...) use
+    ``reasoning_content``; Qwen uses ``reasoning``.  This is the single
+    place that knows the variants — callers (the LLM client's streaming
+    and non-streaming parsers, token estimation) must not open-code the
+    keys.  Non-string values (some backends send a list of parts) are
+    dropped, not coerced.
+    """
+    for key in ("reasoning_content", "reasoning"):
+        value = obj.get(key)
+        if isinstance(value, str) and value:
+            return value
+    return ""
+
+
 @dataclass
 class TextPart:
     """A plain-text content part in a multimodal message."""

{python_agent_harness-1.5.6.5 → python_agent_harness-1.5.6.7}/python_agent_harness/core/token_estimator.py

@@ -12,6 +12,7 @@ import os
 import re
 
 from ..session import config
+from .models import extract_reasoning
 
 
 def is_cjk_char(c: str) -> bool:
@@ -128,8 +129,9 @@ def payload_text(system: object, messages: list[dict], tools: list[dict]) -> str
                         if isinstance(v, str):
                             buf.append(v)
                             break
-        reasoning = msg.get("reasoning_content")
-        if isinstance(reasoning, str):
+        # currently unreachable: Message.to_api() never emits reasoning (and strips it from content)
+        reasoning = extract_reasoning(msg)
+        if reasoning:
             buf.append(reasoning)
         for tc in msg.get("tool_calls") or []:
             fn = tc.get("function", {}) if isinstance(tc, dict) else {}

{python_agent_harness-1.5.6.5 → python_agent_harness-1.5.6.7}/python_agent_harness/llm/client.py

@@ -24,7 +24,15 @@ from typing import Any, Protocol, runtime_checkable
 
 import httpx
 
-from ..core.models import ImagePart, Message, TextPart, ToolCall, ToolSpec, Usage
+from ..core.models import (
+    ImagePart,
+    Message,
+    TextPart,
+    ToolCall,
+    ToolSpec,
+    Usage,
+    extract_reasoning,
+)
 from ..session import config
 
 
@@ -875,11 +883,12 @@ class Client:
                     content_parts.append(delta["content"])
                     if on_delta:
                         on_delta(delta["content"])
-                if delta.get("reasoning_content"):
-                    content_parts.append(delta["reasoning_content"])
-                    reasoning_parts.append(delta["reasoning_content"])
+                reasoning = extract_reasoning(delta)
+                if reasoning:
+                    content_parts.append(reasoning)
+                    reasoning_parts.append(reasoning)
                     if on_delta:
-                        on_delta(delta["reasoning_content"])
+                        on_delta(reasoning)
                 for tc in delta.get("tool_calls") or []:
                     self._absorb_tool_call(
                         tc_index, self._slot_for(tc_index, tc, 0), tc, on_tool_call
@@ -921,7 +930,7 @@ class Client:
         tc_index: dict[int, dict[str, Any]] = {}
         choice = (data.get("choices") or [{}])[0]
         msg = choice.get("message") or {}
-        reasoning = msg.get("reasoning_content") or ""
+        reasoning = extract_reasoning(msg)
         content = msg.get("content") or ""
         # some backends return content as a list of parts (multimodal);
         # normalize to plain text like Message.text() does, so the
@@ -931,8 +940,6 @@ class Client:
                 p.get("text", "") if isinstance(p, dict) else (p if isinstance(p, str) else "")
                 for p in content
             )
-        if not isinstance(reasoning, str):
-            reasoning = ""
         # mirror the streaming order: reasoning first, then the answer
         if reasoning:
             reasoning_parts.append(reasoning)

{python_agent_harness-1.5.6.5 → python_agent_harness-1.5.6.7}/python_agent_harness/prompts/agent.md

@@ -69,21 +69,6 @@ The user will primarily request you perform software engineering tasks. This inc
 - Batch independent tool calls in a single response to maximize parallelism.
 
 # Tool usage instructions
-**Specialized Tools vs. Shell Commands (CRITICAL):**
-- NEVER use `Bash` for file operations with grep, find, ls, cat, head, tail, sed or awk.
-- ALWAYS use: `Glob`, `Grep`, `Read`, `Edit`, `Write`
-- Reserve `Bash` EXCLUSIVELY for: git, npm, docker, cargo, make, system services and other non-file commands
-- Using bash for file operations violates the tool hierarchy and creates technical debt
-
-**Tool Selection Hierarchy:**
-- File search by name → Use `Glob` (NOT find or ls)
-- Directory listing → Use `Glob` with glob pattern `"*"` (not ls)
-- Content search → Use `Grep` (NOT grep or rg)
-- Read files → Use `Read` (NOT cat/head/tail)
-- Edit files → Use `Edit` (NOT sed/awk)
-- Write files → Use `Write` (NOT echo >/cat <<EOF)
-- System operations → Use `Bash` (for git, npm, docker, etc.)
-
 {{TOOL_INSTRUCTIONS}}
 
 # Code References

{python_agent_harness-1.5.6.5 → python_agent_harness-1.5.6.7}/python_agent_harness/prompts/core.py

@@ -500,7 +500,11 @@ def user_prompt_texts(messages: list) -> list[str]:
     (``remember_user_text`` excludes reminders for title generation —
     a different purpose, so the filters differ.)
     """
-    nudge = config.NUDGE_MESSAGE
+    # Harness-injected one-liners replayed verbatim on every compaction
+    # would accumulate: the completion nudge, and the resume message the
+    # automatic compaction appends (a bare "keep going" carries no task
+    # content — the summary already covers the progress it refers to).
+    injected = {config.NUDGE_MESSAGE, config.RESUME_MESSAGE}
     is_reminder: list[bool] = []
     last_reminder = -1
     for msg in messages:
@@ -523,7 +527,7 @@ def user_prompt_texts(messages: list) -> list[str]:
         if _message_role(msg) != "user":
             continue
         text = _message_text(msg)
-        if not text or text == nudge:
+        if not text or text in injected:
             continue
         if text.startswith(config.COMPACT_HEADER):
             continue
@@ -587,19 +591,29 @@ def compact_summary(
     return summary or None
 
 
-def compacted_messages(summary: str, prompts: list[str]) -> list[Message]:
+def compacted_messages(summary: str, prompts: list[str], resume: bool = False) -> list[Message]:
     """The post-compaction history: the summary frame as a user message
     followed by every preserved user prompt, oldest first.
 
     The summary lives in the user turn (the system prompt is passed
     separately and stays untouched); *prompts* are the real user
     requests (see ``user_prompt_texts``) that must survive compaction.
+
+    *resume* appends ``config.RESUME_MESSAGE`` (flagged ``injected``, so
+    the TUI and the filters skip it) after the prompts: without it the
+    rebuilt history ends with a bare user request and the model may redo
+    work the summary already records.  Only the automatic in-loop
+    compaction passes it — the manual /compact command waits for the
+    next user message instead.
     """
     frame = (config.COMPACT_HEADER + summary + config.COMPACT_SEPARATOR).strip()
-    return [
+    messages = [
         Message(role="user", content=frame),
         *[Message(role="user", content=p) for p in prompts],
     ]
+    if resume:
+        messages.append(Message(role="user", content=config.RESUME_MESSAGE, injected=True))
+    return messages
 
 
 # ---- custom agent discovery -----------------------------------------------

{python_agent_harness-1.5.6.5 → python_agent_harness-1.5.6.7}/python_agent_harness/prompts/subagent.md

@@ -20,26 +20,12 @@ You are an autonomous subagent. Your role is to independently complete well-defi
 You MUST answer concisely with fewer than 4 lines of text (not including tool use or code generation), unless user asks for detail.
 
 # Tool usage instructions
-**Specialized Tools vs. Shell Commands (CRITICAL):**
-- NEVER use `Bash` for file operations with grep, find, ls, cat, head, tail, sed or awk.
-- ALWAYS use: `Glob`, `Grep`, `Read`, `Edit`, `Write`
-- Reserve `Bash` EXCLUSIVELY for: git, npm, docker, cargo, make, system services and other non-file commands
-- Using bash for file operations violates the tool hierarchy and creates technical debt
 
 **Parallel Tool Execution:**
 - Call multiple tools in a single response when tasks are independent
 - Never use placeholders or guess missing parameters
 - Maximize parallel execution to improve efficiency
 
-**Tool Selection Hierarchy:**
-- File search by name → Use `Glob` (NOT find or ls)
-- Directory listing → Use `Glob` with glob pattern `"*"` (not ls)
-- Content search → Use `Grep` (NOT grep or rg)
-- Read files → Use `Read` (NOT cat/head/tail)
-- Edit files → Use `Edit` (NOT sed/awk)
-- Write files → Use `Write` (NOT echo >/cat <<EOF)
-- System operations → Use `Bash` (for git, npm, docker, etc.)
-
 {{TOOL_INSTRUCTIONS}}
 
 # Output Requirements

{python_agent_harness-1.5.6.5 → python_agent_harness-1.5.6.7}/python_agent_harness/session/config.py

@@ -44,6 +44,18 @@ NUDGE_MESSAGE = (
 # ---- compaction -----------------------------------------------------------
 COMPACT_HEADER = "**[Compacted Summary]**\n\n"
 COMPACT_SEPARATOR = "\n\n---\n\n**[Context compacted]**\n\n---\n\n"
+# Appended after the summary frame + preserved prompts on the AUTOMATIC
+# path only (AgentLoop -> ContextManager.compact).  The rebuilt history
+# ends with the original user request, and a bare request reads as "start
+# here", so the model tends to redo work the summary already records.  The
+# manual /compact command does NOT inject it: it replaces the history and
+# waits for the next user message.
+RESUME_MESSAGE = (
+    "Compaction just finished; the summary above records the work already done. "
+    "Do not repeat completed steps or re-run finished tool calls. "
+    "Review which parts of the request above are already done "
+    "and continue with the unfinished ones."
+)
 
 # ---- token calibration ----------------------------------------------------
 CALIBRATION_MIN = 0.5
@@ -191,6 +203,11 @@ SUBAGENT_EXCLUDED_TOOLS = ("Agent", "Question", "PlanExit", "TodoWrite")
 TOOL_RESULT_PREVIEW_LINES = 5  # max lines of a tool result shown in the TUI
 TOOL_RESULT_PREVIEW_CHARS = 500  # max chars of that preview (long single lines)
 
+# Per-argument value cap for a tool call the user expanded: the full
+# command/payload is shown, but a runaway (e.g. a 200KB argument) is
+# still trimmed so one row cannot flood the panel.
+TOOL_EXPANDED_ARG_CHARS = 4000
+
 # ---- default agent prompts -----------------------------------------------------
 # Ported system prompts (opencode-style) for the main agent and sub-agents,
 # bundled with the package (prompts/agent.md, prompts/subagent.md).

{python_agent_harness-1.5.6.5 → python_agent_harness-1.5.6.7}/python_agent_harness/session/session.py

@@ -670,14 +670,16 @@ class Session:
     def remember_user_text(self, messages: list) -> None:
         """Remember the last real user message for session-title generation.
 
-        Skips harness-injected messages (nudges, plan/build-switch
-        reminders, queued mode prompts — flagged ``injected``) so a
-        title is never generated from "Review the original user request
-        and the Task Completion Rules…" or a mode-switch reminder.
+        Skips harness-injected messages (nudges, the post-compaction
+        resume message, plan/build-switch reminders, queued mode prompts
+        — flagged ``injected``; the content check also covers restored
+        sessions, where the flag is lost) so a title is never generated
+        from "Review the original user request and the Task Completion
+        Rules…" or a mode-switch reminder.
         """
-        nudge = config.NUDGE_MESSAGE
+        injected = {config.NUDGE_MESSAGE, config.RESUME_MESSAGE}
         for m in reversed(messages):
-            if m.role == "user" and not m.injected and m.text() != nudge:
+            if m.role == "user" and not m.injected and m.text() not in injected:
                 self.store.remember_first_user_message(m.text())
                 break
 

{python_agent_harness-1.5.6.5 → python_agent_harness-1.5.6.7}/python_agent_harness/tui/core.py

@@ -32,6 +32,7 @@ from ..session import config
 from ..session.session import Session
 from .commands import CommandMixin
 from .input import InputMixin, SlashCompleter, UiQuestion, _history_path, _make_prompt_session
+from .mouse import MouseSession, apply_typed
 from .render import RenderMixin, safe_markup
 
 # Unexpected UI exceptions in a row (no successful input read in
@@ -81,6 +82,19 @@ class Tui(RenderMixin, InputMixin, CommandMixin):
         # prompts/agents/ directory; refreshed on each /agent call so files
         # added at runtime are picked up.
         self._discovered_agents: dict[str, str] = {}
+        # Tool calls the user expanded by clicking their ▶ row: their
+        # panel rows carry every argument in full instead of the
+        # truncated one-line label.
+        self._expanded_tools: set[str] = set()
+        # Last rendered frame, so a mouse click can be traced back to
+        # the row it landed on.
+        self._last_frame: Any = None
+        # Mouse session of the run in progress (None outside a run): a
+        # click has to ask the terminal where the panel is on screen.
+        self._mouse: MouseSession | None = None
+        # Text typed while the mouse reader owned the terminal during a
+        # run: replayed into the next input prompt instead of dropped.
+        self._typed_during_run = ""
         self.prompt_session = _make_prompt_session(
             FileHistory(_history_path(str(self._controller.project_dir))),
             SlashCompleter(lambda: str(self._controller.project_dir)),
@@ -377,6 +391,16 @@ class Tui(RenderMixin, InputMixin, CommandMixin):
                 self.console.print()
                 self._flush()
 
+    def _collect_typed(self, text: str) -> None:
+        """Keep text typed while the mouse reader owned the terminal.
+
+        With mouse reporting on, the run owns stdin in cbreak mode, so
+        keystrokes would otherwise be read by the mouse reader and lost.
+        They are buffered here and offered as the next prompt's default
+        instead (see ``InputMixin._read_multiline``).
+        """
+        self._typed_during_run = apply_typed(self._typed_during_run, text)
+
     def _abandon_run(self) -> None:
         """Cancel the active run and release what it holds (UI side)."""
         self._controller.cancel()
@@ -401,25 +425,47 @@ class Tui(RenderMixin, InputMixin, CommandMixin):
         the moment new stream text arrives, so the text pushes the
         scroll immediately instead of waiting for a fixed tick.  The
         short timeout keeps the spinner animating between data bursts.
+
+        While the panel is live, terminal mouse reporting is on
+        (``mouse.MouseSession``) so clicking a ``▶`` tool row expands or
+        collapses it.  Reporting is switched off whenever the input
+        prompt needs the terminal (a pending question) and always on the
+        way out, so normal text selection and typing behave as usual
+        outside a run.
         """
+        mouse = MouseSession(
+            self.console,
+            self._on_mouse_click,
+            on_text=self._collect_typed,
+        )
+        self._mouse = mouse
         with Live(
             self._render_frame(),
             console=self.console,
             refresh_per_second=30,
             screen=False,
         ) as live:
-            while worker.is_alive():
-                if self.question is not None:
-                    live.stop()
-                    self._ask_question_blocking()
-                    live.start()
-                    continue
-                self._data_event.wait(timeout=0.1)
-                self._data_event.clear()
+            mouse.enable()
+            try:
+                while worker.is_alive():
+                    if self.question is not None:
+                        live.stop()
+                        # prompt_toolkit owns stdin here: mouse reports
+                        # would land in the answer buffer as garbage
+                        mouse.disable()
+                        self._ask_question_blocking()
+                        mouse.enable()
+                        live.start()
+                        continue
+                    self._data_event.wait(timeout=0.1)
+                    self._data_event.clear()
+                    live.update(self._render_frame())
+                    self._flush()
                 live.update(self._render_frame())
                 self._flush()
-            live.update(self._render_frame())
-            self._flush()
+            finally:
+                mouse.disable()
+                self._mouse = None
         # run finished: the last Live frame stays on screen, but the
         # in-place redraws never reached the scrollback — print the
         # full conversation so the user can scroll back through it

{python_agent_harness-1.5.6.5 → python_agent_harness-1.5.6.7}/python_agent_harness/tui/input.py

@@ -381,9 +381,14 @@ class InputMixin:
         )
 
     def _read_multiline(self) -> str | None:
+        # Text typed while a run held the terminal (mouse reporting on)
+        # is offered as the default buffer content rather than dropped.
+        default = self._pending_default()
         try:
             with _safe_patch_stdout():
-                text = self.prompt_session.prompt(self._input_prompt(), multiline=True)
+                text = self.prompt_session.prompt(
+                    self._input_prompt(), multiline=True, default=default
+                )
         except EOFError:
             # Ctrl-D: quit
             return None
@@ -393,6 +398,31 @@ class InputMixin:
             return ""
         return text
 
+    def _pending_default(self) -> str:
+        """Text typed during the last run, consumed once.
+
+        Line breaks typed during the run are kept between lines, but
+        stripped at the ends: pressing Enter while waiting (to "wake"
+        the terminal, or to submit) would otherwise seed the prompt
+        with blank lines, and leading whitespace would hide a
+        ``/command`` from the slash dispatcher.
+        """
+        typed = getattr(self, "_typed_during_run", "")
+        if typed:
+            self._typed_during_run = ""
+        # Leading blank lines never matter; leading spaces only go in
+        # front of a "/command" (they would hide it from dispatch), so
+        # pasted indented code keeps its first line's indentation.  At
+        # the end only line breaks go -- a trailing space is part of a
+        # sentence the user goes on typing.
+        lines = typed.split("\n")
+        while lines and not lines[0].strip():
+            lines.pop(0)
+        if lines and lines[0].lstrip().startswith("/"):
+            lines[0] = lines[0].lstrip()
+        typed = "\n".join(lines).rstrip("\n")
+        return typed if typed.strip() else ""
+
     def _ask_question_blocking(self) -> None:
         """Answer the pending question on the main thread.