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

{python_agent_harness-1.5.6.6/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.6
+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.6 → 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.6"
+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.6 → 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.6"
+__version__ = "1.5.6.7"
 
 __all__ = [
     "Client",

{python_agent_harness-1.5.6.6 → 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.6 → 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.6 → 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.6 → python_agent_harness-1.5.6.7}/python_agent_harness/session/config.py

@@ -203,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.6 → 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.6 → 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.