hx-cli 0.2.10__tar.gz → 0.2.11__tar.gz

{hx_cli-0.2.10 → hx_cli-0.2.11}/CHANGELOG.md

@@ -28,6 +28,24 @@ the project follows [semantic versioning](https://semver.org/).
 
 ---
 
+## [0.2.11] - 2026-10-01
+
+### Fixed
+
+- `esc` while a tool runs no longer breaks the session: the next question is
+  answered instead of every later turn failing. A session that was interrupted
+  or killed mid-tool before this release also carries on after `hx resume`.
+- `esc` during a `Bash` command stops the command. The next `Bash` call gets its
+  own output and exit code, not what was left of the one stopped.
+- An interrupted call keeps what it printed, on screen and for the model, and
+  reads "Interrupted after <time>" instead of looking like a failure.
+- A tool that finished keeps its result when `esc` lands while its
+  `PostToolUse` hook runs.
+- `Bash` shows a short line such as "Starting..." as soon as it is printed,
+  rather than only when more output follows.
+
+---
+
 ## [0.2.10] - 2026-09-29
 
 ### Fixed
@@ -758,7 +776,8 @@ First release, published to PyPI as [`hx-cli`](https://pypi.org/project/hx-cli/)
 - `/configure` and `hx auth` for the OpenRouter key, `hx upgrade` for
   self-update, and `install.sh` bootstrapping uv with a pinned Python.
 
-[Unreleased]: https://github.com/aletisunil/hx/compare/v0.2.10...HEAD
+[Unreleased]: https://github.com/aletisunil/hx/compare/v0.2.11...HEAD
+[0.2.11]: https://github.com/aletisunil/hx/compare/v0.2.10...v0.2.11
 [0.2.10]: https://github.com/aletisunil/hx/compare/v0.2.9...v0.2.10
 [0.2.9]: https://github.com/aletisunil/hx/compare/v0.2.8...v0.2.9
 [0.2.8]: https://github.com/aletisunil/hx/compare/v0.2.7...v0.2.8

{hx_cli-0.2.10 → hx_cli-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hx-cli
-Version: 0.2.10
+Version: 0.2.11
 Summary: HX - an agent harness for the terminal
 Project-URL: Homepage, https://hx.sunilaleti.dev
 Project-URL: Documentation, https://hx.sunilaleti.dev

{hx_cli-0.2.10 → hx_cli-0.2.11}/src/hx/__init__.py

@@ -1,5 +1,5 @@
 """HX - an agent harness for the terminal."""
 
-__version__ = "0.2.10"
+__version__ = "0.2.11"
 
 __all__ = ["__version__"]

{hx_cli-0.2.10 → hx_cli-0.2.11}/src/hx/core/events.py

@@ -67,6 +67,9 @@ class ToolCallFinished(Event):
     metadata: dict[str, Any] = field(default_factory=dict)
     """Structured detail the renderer draws with - an edit's diff, a command's
     exit code. Presentation only: the model never sees it."""
+    interrupted: bool = False
+    """The user stopped the turn while this call ran. Whatever it streamed is
+    kept: how far a command got is what the user wants to see."""
 
 
 @dataclass(slots=True)

{hx_cli-0.2.10 → hx_cli-0.2.11}/src/hx/core/loop.py

@@ -42,7 +42,9 @@ from hx.core.messages import (
     ToolResultBlock,
     ToolUseBlock,
     UserTurn,
+    answer_unanswered_calls,
     assistant_message,
+    interrupted_result,
     tool_result_message,
     user_message,
 )
@@ -50,7 +52,7 @@ from hx.core.session import Environment
 from hx.core.usage import TurnUsage, compute_cost
 from hx.hooks.spec import HookOutcome
 from hx.providers.base import ProviderError, ProviderRequest, StreamDelta, StreamEnd
-from hx.tools.base import ToolContext
+from hx.tools.base import ToolContext, ToolResult
 
 if TYPE_CHECKING:
     from collections.abc import Awaitable, Callable, Sequence
@@ -225,6 +227,27 @@ class AgentLoop:
                 self.bus.publish(TurnFinished(self._turn_index, stop_reason))
 
             calls = message.tool_uses()
+            if calls and self._cancelled:
+                # Stopped between the answer and its tools: none of them ran,
+                # and the transcript has to say so before the turn ends - as
+                # does the screen, which a resumed session draws them on too.
+                for call in calls:
+                    self.bus.publish(
+                        ToolCallStarted(
+                            tool_use_id=call.id,
+                            name=self._display_name(call.name),
+                            input=call.input,
+                        )
+                    )
+                    self.bus.publish(
+                        ToolCallFinished(
+                            tool_use_id=call.id,
+                            is_error=True,
+                            summary="interrupted",
+                            interrupted=True,
+                        )
+                    )
+                produced.append(self._answer_calls(calls, {}))
             if not calls or self._cancelled:
                 # A steer that arrived during the last stretch is the next thing
                 # the user said, so the conversation continues rather than
@@ -234,10 +257,15 @@ class AgentLoop:
                 await self._name_session()
                 return TurnResult(stop_reason, produced)
 
-            results = await self._execute_tools(calls)
-            result_message = tool_result_message(results)
-            self.session.append(result_message)
-            produced.append(result_message)
+            results: dict[str, ToolResultBlock] = {}
+            try:
+                await self._execute_tools(calls, results)
+            finally:
+                # Also on interrupt. The calls are already in the transcript,
+                # and a call left without a result is rejected by every route on
+                # the next request - so every later turn in the session would
+                # fail the same way. What finished keeps its real result.
+                produced.append(self._answer_calls(calls, results))
 
         self.bus.publish(
             ErrorRaised(message=f"Stopped after {self.MAX_TURNS} turns", recoverable=True)
@@ -459,7 +487,9 @@ class AgentLoop:
         )
 
     async def _build_request(self) -> ProviderRequest:
-        messages = await self.injections.apply(self.session.active_messages())
+        messages = answer_unanswered_calls(
+            await self.injections.apply(self.session.active_messages())
+        )
         if self.model_info is None or not self.model_info.supports_images:
             from hx.core.images import without_images
 
@@ -570,31 +600,48 @@ class AgentLoop:
             )
         )
 
-    async def _execute_tools(self, calls: list[ToolUseBlock]) -> list[ToolResultBlock]:
+    async def _execute_tools(
+        self, calls: list[ToolUseBlock], results: dict[str, ToolResultBlock]
+    ) -> None:
         """Permission-check, then run. Read-only calls are gathered concurrently;
         mutating calls run in emission order.
 
+        Each result lands in ``results`` the moment its call finishes, so an
+        interrupt keeps what had already run.
+
         A denied call becomes an ``is_error`` result rather than an exception, so
         the model can react instead of the turn dying.
         """
-        results: dict[str, ToolResultBlock] = {}
         concurrent: list[ToolUseBlock] = []
 
+        async def run(call: ToolUseBlock) -> None:
+            results[call.id] = await self._run_one(call, results)
+
         for call in calls:
             if self._runs_serially(call):
                 for pending in concurrent:
-                    results[pending.id] = await self._run_one(pending)
+                    await run(pending)
                 concurrent.clear()
-                results[call.id] = await self._run_one(call)
+                await run(call)
             else:
                 concurrent.append(call)
 
         if concurrent:
-            gathered = await asyncio.gather(*(self._run_one(c) for c in concurrent))
-            for call, result in zip(concurrent, gathered, strict=True):
-                results[call.id] = result
+            await asyncio.gather(*(run(c) for c in concurrent))
 
-        return [results[c.id] for c in calls]
+    def _answer_calls(
+        self, calls: list[ToolUseBlock], results: dict[str, ToolResultBlock]
+    ) -> Message:
+        """Append the results for ``calls``, in the order the model asked for them.
+
+        A call with no result was cut off by the user, before it started or
+        while it ran, and is answered as exactly that.
+        """
+        message = tool_result_message(
+            [results.get(call.id) or interrupted_result(call.id) for call in calls]
+        )
+        self.session.append(message)
+        return message
 
     def _runs_serially(self, call: ToolUseBlock) -> bool:
         try:
@@ -609,7 +656,10 @@ class AgentLoop:
         """Attribute a subagent's tool calls so they do not read as the parent's."""
         return name if self.origin is None else f"{self.origin} > {name}"
 
-    async def _run_one(self, call: ToolUseBlock) -> ToolResultBlock:
+    async def _run_one(
+        self, call: ToolUseBlock, results: dict[str, ToolResultBlock]
+    ) -> ToolResultBlock:
+        """Run one call. Interrupted, it leaves its answer in ``results``."""
         started = time.monotonic()
 
         # PreToolUse runs before the call is announced. A hook that rewrites the
@@ -626,7 +676,40 @@ class AgentLoop:
                 tool_use_id=call.id, name=self._display_name(call.name), input=call.input
             )
         )
+        streamed: list[str] = []
+        try:
+            return await self._run_announced(call, pre, started, streamed, results)
+        except asyncio.CancelledError:
+            if call.id in results:
+                # The tool had finished and only its hooks were cut off.
+                raise
+            cap = self.settings.context.tool_output_char_cap
+            results[call.id] = interrupted_result(call.id, "".join(streamed)[-cap:])
+            # The call is on screen as running; left alone it would spin on
+            # under the "Interrupted" notice for the rest of the session.
+            self.bus.publish(
+                ToolCallFinished(
+                    tool_use_id=call.id,
+                    is_error=True,
+                    duration_ms=(time.monotonic() - started) * 1000,
+                    summary="interrupted",
+                    interrupted=True,
+                )
+            )
+            raise
 
+    async def _run_announced(
+        self,
+        call: ToolUseBlock,
+        pre: HookOutcome,
+        started: float,
+        streamed: list[str],
+        results: dict[str, ToolResultBlock],
+    ) -> ToolResultBlock:
+        """The part of :meth:`_run_one` after the call is on screen.
+
+        What the tool prints is kept in ``streamed`` for an interrupt to report.
+        """
         if pre.blocked:
             refusal = ToolResultBlock(
                 tool_use_id=call.id,
@@ -657,18 +740,34 @@ class AgentLoop:
             )
             return denied
 
+        def progress(chunk: str) -> None:
+            streamed.append(chunk)
+            self._emit_progress(call.id, chunk)
+
         ctx = ToolContext(
             cwd=self.settings.cwd,
             session_id=self.session.meta.session_id,
             tool_use_id=call.id,
             settings=self.settings,
-            emit_progress=lambda chunk: self._emit_progress(call.id, chunk),
+            emit_progress=progress,
         )
         result = await self.tools.call(call.name, call.input, ctx)
 
-        post = await self._fire_hooks(
-            lambda h: h.post_tool_use(call.name, call.input, result.content, result.is_error)
-        )
+        try:
+            post = await self._fire_hooks(
+                lambda h: h.post_tool_use(call.name, call.input, result.content, result.is_error)
+            )
+        except asyncio.CancelledError:
+            # The tool finished and its effects are real: its own result stands,
+            # rather than telling the model a write that happened never did.
+            results[call.id] = self._finish(call, result, HookOutcome(), started)
+            raise
+        return self._finish(call, result, post, started)
+
+    def _finish(
+        self, call: ToolUseBlock, result: ToolResult, post: HookOutcome, started: float
+    ) -> ToolResultBlock:
+        """Announce a call the tool finished, and its result for the model."""
         content = result.content
         if post.blocked:
             content = f"{content}\n\nA hook rejected this result: {post.reason}"

{hx_cli-0.2.10 → hx_cli-0.2.11}/src/hx/core/messages.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 import time
 from collections.abc import Sequence
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from enum import StrEnum
 from typing import Any, Literal
 
@@ -238,3 +238,60 @@ def assistant_message(blocks: list[ContentBlock], model: str | None = None) -> M
 def tool_result_message(results: list[ToolResultBlock]) -> Message:
     """Tool results are carried on a ``user``-role message, matching the provider wire format."""
     return Message(role="user", content=list(results))
+
+
+INTERRUPTED = "Interrupted by the user before this call finished."
+_OUTPUT_SO_FAR = "\n\nOutput before the interrupt:\n"
+
+
+def interrupted_result(tool_use_id: str, output: str = "") -> ToolResultBlock:
+    """The answer for a call the user cut off, before it started or while it ran.
+
+    What it printed before then goes with it: how far a command got is what
+    the model needs to decide whether to run it again.
+    """
+    content = f"{INTERRUPTED}{_OUTPUT_SO_FAR}{output}" if output.strip() else INTERRUPTED
+    return ToolResultBlock(tool_use_id=tool_use_id, content=content, is_error=True)
+
+
+def interrupted_output(result: ToolResultBlock) -> str | None:
+    """What an interrupted call printed, or ``None`` when ``result`` is not one."""
+    if not (result.is_error and result.content.startswith(INTERRUPTED)):
+        return None
+    return result.content.removeprefix(INTERRUPTED).removeprefix(_OUTPUT_SO_FAR)
+
+
+def answer_unanswered_calls(messages: Sequence[Message]) -> list[Message]:
+    """``messages`` with every tool call answered by the message after it.
+
+    The loop answers every call it starts, interrupted or not, so a request is
+    never built while a call waits. A transcript can still hold a call with no
+    result: written before the loop did that, or by a process killed mid-tool.
+    Every route rejects such a call - on every request after it, since it never
+    leaves the history - so the missing results are filled in as interrupted.
+    Only the request is repaired; the transcript on disk keeps what happened.
+    """
+    repaired: list[Message] = []
+    waiting: list[ToolUseBlock] = []
+    for message in [*messages, None]:
+        if waiting:
+            results = {r.tool_use_id: r for r in message.tool_results()} if message else {}
+            if any(call.id not in results for call in waiting):
+                answers = [results.get(c.id) or interrupted_result(c.id) for c in waiting]
+                ids = {call.id for call in waiting}
+                if message is not None and results:
+                    # Into the results already there: the calls stay answered
+                    # by one message, in the order they were made.
+                    rest = [
+                        b
+                        for b in message.content
+                        if not (isinstance(b, ToolResultBlock) and b.tool_use_id in ids)
+                    ]
+                    message = replace(message, content=[*answers, *rest])
+                else:
+                    repaired.append(tool_result_message(answers))
+        if message is None:
+            break
+        repaired.append(message)
+        waiting = message.tool_uses() if message.role == "assistant" else []
+    return repaired

{hx_cli-0.2.10 → hx_cli-0.2.11}/src/hx/tools/bash.py

@@ -143,6 +143,13 @@ class PersistentShell:
                 if not interrupted or not await self._drain_stale_sentinel():
                     await self.restart()
                     yield "[hx] shell did not recover from the interrupt; restarted\n"
+            except asyncio.CancelledError:
+                # The user stopped the turn. The command must stop with it, and
+                # its sentinel must not be left for the next command to read -
+                # the same recovery as a timeout, without the output to report.
+                if not await self.interrupt() or not await self._drain_stale_sentinel():
+                    await self.restart()
+                raise
 
             self._duration_ms = (time.monotonic() - started) * 1000
 
@@ -178,11 +185,14 @@ class PersistentShell:
                     yield head
                 return
 
-            # Hold back a partial sentinel so it is never emitted as output.
-            safe = len(buffer) - len(self._sentinel)
-            if safe > 0:
-                yield buffer[:safe]
-                buffer = buffer[safe:]
+            # Hold back only what could be the start of the sentinel, so it is
+            # never emitted as output. Holding back a sentinel's length of
+            # anything hid a short line - "Starting..." before a long build -
+            # until the command ended.
+            held = _sentinel_prefix_at_end(buffer, self._sentinel)
+            if len(buffer) > held:
+                yield buffer[: len(buffer) - held]
+                buffer = buffer[len(buffer) - held :]
 
     async def _drain_stale_sentinel(self, timeout_seconds: float = 5.0) -> bool:
         """Consume output up to the sentinel owed by an interrupted command."""
@@ -564,6 +574,14 @@ class KillShellTool(Tool):
         return ToolResult(content=f"Killed {job_id}.", summary=f"killed {job_id}")
 
 
+def _sentinel_prefix_at_end(buffer: str, sentinel: str) -> int:
+    """Length of the longest end of ``buffer`` that ``sentinel`` starts with."""
+    for size in range(min(len(buffer), len(sentinel) - 1), 0, -1):
+        if sentinel.startswith(buffer[-size:]):
+            return size
+    return 0
+
+
 def _parse_trailer(tail: str, previous: Path) -> tuple[int, Path]:
     """Read the ``<status> <pwd>`` the sentinel is followed by.
 

{hx_cli-0.2.10 → hx_cli-0.2.11}/src/hx/tui/renderers.py

@@ -69,6 +69,7 @@ class ToolCall:
     finished: bool = False
     expanded: bool = False
     duration_ms: float = 0.0
+    interrupted: bool = False
 
 
 #: Fields of a :class:`ToolCall` carrying text somebody else wrote.
@@ -525,9 +526,10 @@ class BashRenderer(ToolRenderer):
             lines, hidden = _tail(output, self.preview_lines, call.expanded)
             if hidden:
                 out.append(expand_note(hidden))
-            role = "error" if call.is_error else "tool_output"
+            # Cut off, it printed what it printed: that is output, not an error.
+            role = "error" if call.is_error and not call.interrupted else "tool_output"
             out.extend(fg(role, line) for line in lines)
-        if call.finished and call.duration_ms:
+        if call.finished and call.duration_ms and not call.interrupted:
             out.append(fg("dim", f"Took {format_duration(call.duration_ms)}"))
         return out
 
@@ -703,7 +705,7 @@ def _plain_output(call: ToolCall, limit: int) -> list[str]:
     if not call.output.strip():
         return []
     lines, hidden = _head(call.output, limit, call.expanded)
-    role = "error" if call.is_error else "tool_output"
+    role = "error" if call.is_error and not call.interrupted else "tool_output"
     out = [fg(role, line) for line in lines]
     return [*out, expand_note(hidden)] if hidden else out
 

{hx_cli-0.2.10 → hx_cli-0.2.11}/src/hx/tui/runtime.py

@@ -23,6 +23,7 @@ from hx.core.messages import (
     ToolResultBlock,
     ToolUseBlock,
     UserTurn,
+    interrupted_output,
 )
 from hx.core.usage import format_tokens
 from hx.git import BranchWatcher
@@ -628,7 +629,11 @@ class HXSession:
         is the part the reader came back for.
         """
         params = dict(call.input or {})
-        failed = result is not None and result.is_error
+        # No result at all is a call cut off by a version of HX that did not
+        # answer interrupted calls - the same thing, said the old way.
+        printed = "" if result is None else interrupted_output(result)
+        interrupted = printed is not None
+        failed = interrupted or (result is not None and result.is_error)
         if call.name.lower() in SILENT_TOOLS and not failed:
             return TodoBlock(params.get("todos") or [])
         return ToolBlock(
@@ -636,11 +641,10 @@ class HXSession:
                 name=call.name,
                 params=params,
                 cwd=Path(self.settings.cwd),
-                output=result.content if result is not None else "",
+                output=result.content if result is not None and printed is None else printed or "",
                 is_error=failed,
-                # No result means the turn was interrupted mid-call, and the
-                # block says so rather than claiming a finish that never came.
-                finished=result is not None,
+                finished=True,
+                interrupted=interrupted,
             )
         )
 
@@ -1276,6 +1280,7 @@ class HXSession:
                             output=event.detail or finished.call.output,
                             metadata=event.metadata,
                             duration_ms=event.duration_ms or 0.0,
+                            interrupted=event.interrupted,
                         )
                         if held and event.is_error:
                             transcript.append(finished)

{hx_cli-0.2.10 → hx_cli-0.2.11}/src/hx/tui/views/blocks.py

@@ -23,7 +23,13 @@ from hx.term.sanitize import plain_text
 from hx.tui.glyphs import IMAGE, NOTICE, SPINNER, TOOL_DONE, TOOL_FAILED
 from hx.tui.limits import PREVIEW_LINES, STREAM_TAIL
 from hx.tui.paint import ThemePainter, fg, tint
-from hx.tui.renderers import ToolCall, renderer_for, sanitized_call, sanitized_fields
+from hx.tui.renderers import (
+    ToolCall,
+    format_duration,
+    renderer_for,
+    sanitized_call,
+    sanitized_fields,
+)
 
 if TYPE_CHECKING:
     from hx.core.messages import ImageBlock
@@ -237,6 +243,8 @@ class ToolBlock(Widget):
     def _state(self) -> str:
         if not self._call.finished:
             return "running"
+        if self._call.interrupted:
+            return "interrupted"
         return "error" if self._call.is_error else "done"
 
     def draw(self, width: int) -> list[str]:
@@ -246,6 +254,8 @@ class ToolBlock(Widget):
             "running": (SPINNER[self._frame], "accent", "tool_pending_bg"),
             "done": (TOOL_DONE, "success", "tool_success_bg"),
             "error": (TOOL_FAILED, "error", "tool_error_bg"),
+            # Stopped, not failed: the warning the "Interrupted" line is drawn in.
+            "interrupted": (TOOL_FAILED, "warning", "tool_pending_bg"),
         }[state]
 
         renderer = renderer_for(self._call.name)
@@ -253,6 +263,12 @@ class ToolBlock(Widget):
         # The body is indented to sit under the header's text rather than under
         # its marker, so the block has one left edge instead of two.
         lines += [f"  {line}" for line in renderer.body(self._call)]
+        if self._call.interrupted:
+            took = self._call.duration_ms
+            lines.append(
+                "  "
+                + fg("warning", f"Interrupted{f' after {format_duration(took)}' if took else ''}")
+            )
 
         return Box(1, 1, tint(background), Lines(lines, padding_x=0)).render(width)
 

{hx_cli-0.2.10 → hx_cli-0.2.11}/tests/e2e/stub.py

@@ -160,6 +160,22 @@ def _text(content: Any) -> str:
     return ""
 
 
+def _unanswered_tool_calls(messages: list[dict[str, Any]]) -> list[str]:
+    """Tool call ids not answered by the ``tool`` messages that follow their call."""
+    unanswered: list[str] = []
+    for index, message in enumerate(messages):
+        ids = [c.get("id", "") for c in message.get("tool_calls") or []]
+        if not ids:
+            continue
+        answered: set[str] = set()
+        for reply in messages[index + 1 :]:
+            if reply.get("role") != "tool":
+                break
+            answered.add(str(reply.get("tool_call_id")))
+        unanswered.extend(i for i in ids if i not in answered)
+    return unanswered
+
+
 class Stub:
     """The server, and the script it plays."""
 
@@ -263,6 +279,23 @@ class Stub:
                         stub.title_requests.append(request)
                     self._stream(Reply(text=stub.title, prompt_tokens=300, completion_tokens=5))
                     return
+                if unanswered := _unanswered_tool_calls(request.messages):
+                    # Every upstream rejects a tool call left without its
+                    # result - OpenAI, Anthropic and the Codex Responses
+                    # backend alike - so the stub does too, in OpenAI's words.
+                    stub.unexpected.append(f"tool calls without results: {unanswered}")
+                    self._json(
+                        400,
+                        {
+                            "error": {
+                                "message": "An assistant message with 'tool_calls' must be "
+                                "followed by tool messages responding to each "
+                                "'tool_call_id'. The following tool_call_ids did not have "
+                                f"response messages: {', '.join(unanswered)}"
+                            }
+                        },
+                    )
+                    return
                 with stub._arrived:
                     stub.requests.append(request)
                     reply = stub._script.popleft() if stub._script else None

{hx_cli-0.2.10 → hx_cli-0.2.11}/tests/e2e/terminal.py

@@ -368,6 +368,11 @@ class Terminal:
         assert self.exit_code is not None
         return self.exit_code
 
+    def kill(self) -> None:
+        """SIGKILL: the process dies with no chance to tidy up, as in a crash."""
+        os.kill(self.pid, signal.SIGKILL)
+        self.wait_exit(3)
+
     def close(self) -> None:
         if self.alive:
             with contextlib.suppress(ProcessLookupError):
@@ -378,8 +383,12 @@ class Terminal:
             with contextlib.suppress(ProcessLookupError):
                 os.kill(self.pid, signal.SIGKILL)
             self.wait_exit(3)
-        with contextlib.suppress(OSError):
-            os.close(self.fd)
+        # Once only: a closed descriptor's number goes to the next terminal
+        # opened, and closing it again would close that one's pty under it.
+        if self.fd >= 0:
+            with contextlib.suppress(OSError):
+                os.close(self.fd)
+            self.fd = -1
 
     # -- the report ------------------------------------------------------