zettcode 0.1.9__tar.gz → 0.1.10__tar.gz

{zettcode-0.1.9 → zettcode-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: zettcode
-Version: 0.1.9
+Version: 0.1.10
 Summary: A focused terminal coding agent powered by zett-agent
 Project-URL: Repository, https://github.com/Chang-LeHung/zettcode
 Project-URL: Issues, https://github.com/Chang-LeHung/zettcode/issues
@@ -32,7 +32,7 @@ Requires-Dist: truststore<1,>=0.10
 Requires-Dist: uvicorn<1,>=0.35
 Requires-Dist: wcwidth<1,>=0.2
 Requires-Dist: websockets<17,>=15
-Requires-Dist: zett-agent<0.2,>=0.1.17
+Requires-Dist: zett-agent<0.3,>=0.2.0
 Description-Content-Type: text/markdown
 
 # ZettCode

{zettcode-0.1.9 → zettcode-0.1.10}/pyproject.toml

@@ -53,7 +53,7 @@ dependencies = [
   # than it did. An exact pin would make zettcode fight every other tool that
   # shares the dependency — including an upgrade of zett-agent itself, which pip
   # would downgrade to satisfy it.
-  "zett-agent>=0.1.17,<0.2",
+  "zett-agent>=0.2.0,<0.3",
 ]
 
 [project.scripts]

{zettcode-0.1.9 → zettcode-0.1.10}/src/zettcode/__init__.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
 
 #: The one place the version is written. ``pyproject.toml`` reads it from here
 #: and the release workflow checks the tag against it, so a bump is one edit.
-__version__ = "0.1.9"
+__version__ = "0.1.10"
 
 #: Where each public name lives; read by :func:`__getattr__` on first use.
 _EXPORTS = {

{zettcode-0.1.9 → zettcode-0.1.10}/src/zettcode/app/agent/agent/settings.py

@@ -14,6 +14,7 @@ from zettcode.config_edit import (
     remove_model,
     replace_model,
     set_pet,
+    set_pet_position,
     set_self_compaction,
     set_statusline,
     set_theme,
@@ -208,6 +209,29 @@ class SettingsMixin(AgentBase):
         self.runtime.config = replace(self.runtime.config, pet=name)
         return self.config_file
 
+    def remember_pet_position(self, across: float, down: float) -> Path:
+        """Write ``[ui] pet_position`` into the config file, so the next start puts the pet back where it was left.
+
+        The file is global to the reader (``~/.zettcode/config.toml``), not to a project: a pet is the reader's
+        companion, and it does not move house when they open another folder. Only that line changes, and a
+        config file that does not exist is not created for it.
+
+        Returns:
+            The file written.
+
+        Raises:
+            ConfigEditError: When there is no config file, it cannot be read or edited safely, or it cannot be
+                written. Nothing is written then.
+        """
+        text = set_pet_position(self._read_config_file(), across, down, where=self.config_file)
+        try:
+            write_text_atomically(self.config_file, text)
+        except OSError as error:
+            raise ConfigEditError(f"{self.config_file} could not be written: {error}") from error
+        position = (round(min(1.0, max(0.0, across)), 3), round(min(1.0, max(0.0, down)), 3))
+        self.runtime.config = replace(self.runtime.config, pet_position=position)
+        return self.config_file
+
     @property
     def statusline_hidden(self) -> frozenset[str]:
         """Return the names of the header and status-line parts the reader switched off."""
@@ -322,6 +346,15 @@ class SettingsMixin(AgentBase):
         """Return the permission levels, strictest first."""
         return tuple(level.value for level in PERMISSION_LEVELS)
 
-    def use_permission(self, name: str | Permission) -> Permission:
-        """Set how much of the shell may run without asking, for the rest of this run."""
-        return self.runtime.use_permission(name)
+    def use_permission(self, name: str | Permission, *, remember: bool = True) -> Permission:
+        """Set how much of the shell may run without asking, and by default remember it for this session."""
+        return self.runtime.use_permission(name, remember=remember)
+
+    @property
+    def harness(self) -> bool:
+        """Return whether the just-in-time harness is on for the next request."""
+        return self.runtime.harness.on
+
+    def use_harness(self, on: bool) -> bool:
+        """Turn the just-in-time harness on or off for later requests, for the rest of this run."""
+        return self.runtime.use_harness(on)

{zettcode-0.1.9 → zettcode-0.1.10}/src/zettcode/app/agent/conversation/presenters.py

@@ -106,6 +106,8 @@ TOOL_ROLES = {
     "view_image": "image",
     "glob": "search",
     "grep": "search",
+    "web_search": "web-search",
+    "ask_user": "ask-user",
     "write_file": "write",
     "edit": "write",
     "replace_in_file": "write",  # what a session stored before the rename called it
@@ -120,8 +122,12 @@ TOOL_ROLES = {
 
 
 def tool_color(tool: str, theme: Theme) -> str:
-    """Return the colour one tool paints its rows with."""
-    return getattr(theme.tools, TOOL_ROLES.get(tool, ""), theme.accent)
+    """Return the colour one tool paints its rows with.
+
+    A role spelled with a hyphen (``web-search``) names the theme field it stands for (``web_search``).
+    """
+    role = TOOL_ROLES.get(tool, "").replace("-", "_")
+    return getattr(theme.tools, role, theme.accent)
 
 
 #: The entry fields that are not part of how a row looks: its identity, and the
@@ -575,7 +581,12 @@ class ToolPresenter(Presenter[T]):
             }.get(entry.status, STATUS)
         )
         hue = tool_color(entry.tool, theme)
-        colour = theme.error if entry.status is EntryStatus.FAILED else hue
+        # A failure is the error colour, and a row that did not happen at all — a skipped tool, a cancelled
+        # question — is a caution rather than a result, so it is amber and not the tool's own hue.
+        colour = {
+            EntryStatus.FAILED: theme.error,
+            EntryStatus.SKIPPED: theme.warning,
+        }.get(entry.status, hue)
         marker = Style(foreground=colour)
         label = Style(foreground=colour)
         muted = Style(foreground=theme.muted)

{zettcode-0.1.9 → zettcode-0.1.10}/src/zettcode/app/agent/conversation/projection.py

@@ -10,11 +10,12 @@ from zett_agent.events import AgentEvent
 from zett_agent.extensions.shell_approval import SHELL_APPROVAL_EVENT_NAME
 from zett_agent.messages import ToolMessage
 
-from ..dialogue.ask import AskUserQuestion, question_from
+from ..dialogue.ask import AskUserQuestion, declined_answer, question_from
 from ..dialogue.relay import Relayed
 from ..extensions.mcp_notice import MCP_NOTICE_EVENT_NAME, notice_from
 from ..extensions.usage import USAGE_EVENT_NAME
 from .entries import EntryStatus
+from .server_tools import ServerToolRun, describe_output
 from .stops import stop_text
 from .transcript import Transcript
 
@@ -82,6 +83,10 @@ class TranscriptProjector(AgentEventDispatcher):
         self.on_usage = on_usage
         self.on_steering_started = on_steering_started
         self.on_steering_interrupted = on_steering_interrupted
+        #: What a hosted tool was called with while it streams: a start may carry the whole input, or only its
+        #: opening and then fragments. Kept per request and dropped when the call reports back.
+        self._server_inputs: dict[str, dict[str, object]] = {}
+        self._server_fragments: dict[str, str] = {}
 
     def begin_turn(self, prompt: str, *, side: bool = False, relayed: Relayed | None = None) -> None:
         """Echo the prompt into the transcript before the run starts.
@@ -171,9 +176,19 @@ class TranscriptProjector(AgentEventDispatcher):
             self.transcript.start_tool(call.id, call.name, call.arguments)
 
     async def on_tool_completed_event(self, event: AgentEvent) -> None:
-        """Attach the returned message to the row of the call it answers."""
+        """Attach the returned message to the row of the call it answers.
+
+        A question the reader cancelled comes back as a result, not a failure: the model reads that it was declined
+        and carries on. The row is marked skipped so it does not look like a question that was answered.
+        """
         if isinstance(event.message, ToolMessage):
-            self.transcript.complete_tool(event.message.tool_call_id, tool_output(event.message))
+            output = tool_output(event.message)
+            declined = event.message.name == "ask_user" and declined_answer(output)
+            self.transcript.complete_tool(
+                event.message.tool_call_id,
+                output,
+                status=EntryStatus.SKIPPED if declined else EntryStatus.COMPLETED,
+            )
 
     async def on_tool_failed_event(self, event: AgentEvent) -> None:
         """Fail every call in the batch and record the error text."""
@@ -188,23 +203,56 @@ class TranscriptProjector(AgentEventDispatcher):
             self.transcript.complete_tool(call.id, output, status=EntryStatus.SKIPPED)
 
     async def on_server_tool_started_event(self, event: AgentEvent) -> None:
-        """Open a row for a tool the server runs on the agent's behalf."""
-        if event.server_tool_call is not None:
-            self.transcript.start_tool(event.server_tool_call.id, event.server_tool_call.name, {})
+        """Open a row for a tool the server runs on the agent's behalf, with what it was asked."""
+        call = event.server_tool_call
+        if call is None:
+            return
+        arguments = dict(call.input or {})
+        self._server_inputs[call.id] = arguments
+        self._server_fragments.pop(call.id, None)
+        self.transcript.start_tool(call.id, call.name, arguments)
+
+    async def on_server_tool_input_delta_event(self, event: AgentEvent) -> None:
+        """Keep the fragments of a hosted call's input; the query a search ran is in there."""
+        delta = event.server_tool_input_delta
+        if delta is not None:
+            self._server_fragments[delta.call_id] = self._server_fragments.get(delta.call_id, "") + delta.delta
+
+    def _server_arguments(self, call_id: str) -> dict[str, object]:
+        """Return what a hosted call turned out to be called with: its opening input and its fragments."""
+        arguments = dict(self._server_inputs.pop(call_id, {}))
+        fragments = self._server_fragments.pop(call_id, "")
+        if fragments:
+            try:
+                parsed = json.loads(fragments)
+            except ValueError:
+                parsed = None
+            if isinstance(parsed, dict):
+                arguments.update(parsed)
+        return arguments
 
     async def on_server_tool_completed_event(self, event: AgentEvent) -> None:
-        """Attach a server tool result to its row."""
+        """Attach a hosted tool's result to its row: the pages it found, never the provider's payload."""
         result = event.server_tool_result
         if result is not None:
-            self.transcript.complete_tool(result.call_id, serialize(result.output))
+            arguments = self._server_arguments(result.call_id)
+            if arguments:
+                # The row opened before its input had streamed in; now it knows what was searched for.
+                self.transcript.restate_tool(result.call_id, arguments)
+            run = ServerToolRun(result.call_id, result.name, arguments, output=result.output, error=result.error_code)
+            self.transcript.complete_tool(result.call_id, describe_output(run) or serialize(result.output))
 
     async def on_server_tool_failed_event(self, event: AgentEvent) -> None:
-        """Attach a server tool failure, preferring the error code over the payload."""
+        """Attach a hosted tool's failure, preferring the error code over the payload."""
         result = event.server_tool_result
         if result is not None:
+            arguments = self._server_arguments(result.call_id)
+            if arguments:
+                self.transcript.restate_tool(result.call_id, arguments)
+            run = ServerToolRun(result.call_id, result.name, arguments, output=result.output, error=result.error_code)
             self.transcript.complete_tool(
                 result.call_id,
-                result.error_code or serialize(result.output),
+                describe_output(run) or serialize(result.output),
                 status=EntryStatus.FAILED,
             )
 

{zettcode-0.1.9 → zettcode-0.1.10}/src/zettcode/app/agent/conversation/rendering.py

@@ -34,7 +34,7 @@ from zettcode.tui import ELLIPSIS, SEPARATOR
 from zettcode.tui.render import GENERIC, language_for
 
 from .entries import DeleteEntry, EditEntry, MessageEntry, ReadEntry, ToolEntry, WriteEntry
-from .text import limit_output
+from .text import DECLINED_NOTE, limit_output
 
 #: Output kinds the chain shapes; a link claims one or more of them.
 TOOL = "tool"
@@ -386,8 +386,8 @@ class WriteTool(ToolHandler):
     names = frozenset({"write_file"})
 
     def describe(self, name: str, arguments: Mapping[str, object]) -> ToolRow:
-        """Show the file being written."""
-        return ToolRow(f"Wrote {argument(arguments, 'path', '(unknown file)')}")
+        """Show the file being written: the row is the call, so it says what the call does, not what it did."""
+        return ToolRow(f"Write {argument(arguments, 'path', '(unknown file)')}")
 
     def open_tool(
         self, name: str, arguments: Mapping[str, object], *, id: int, call_id: str, started_at: float
@@ -497,6 +497,60 @@ class SearchTool(ToolHandler):
         return ToolRow(f"Searched {pattern or 'the workspace'}" + (f" in {where}" if where else ""))
 
 
+class WebSearchTool(ToolHandler):
+    """``web_search``: a search the endpoint ran, so the row says what was searched for."""
+
+    names = frozenset({"web_search"})
+
+    def describe(self, name: str, arguments: Mapping[str, object]) -> ToolRow:
+        """Name the query; the call is the endpoint's, so nothing else of it is ours to show."""
+        query = argument(arguments, "query")
+        return ToolRow(f'Searched the web for "{query}"' if query else "Searched the web")
+
+
+class AskUserTool(ToolHandler):
+    """``ask_user``: the one row that waited for a person, so it is named as a thing, not as a verb.
+
+    The body is what the person did, not the protocol: the tool answers with the payload the shell sent, and that
+    JSON is neither readable nor useful in a transcript.
+    """
+
+    names = frozenset({"ask_user"})
+
+    def describe(self, name: str, arguments: Mapping[str, object]) -> ToolRow:
+        """Show the question that was put, under the name the shell gives that tool."""
+        question = argument(arguments, "question")
+        return ToolRow(f"Ask-User: {question}" if question else "Ask-User")
+
+    def body(self, name: str, output: str) -> str:
+        """Say what the person did: declined, answered, or answered with a picture.
+
+        Anything that is not the answer payload is left exactly as it came, so a failure or another tool's result
+        is never rewritten by this row.
+        """
+        payload = _ask_payload(output)
+        if payload is None:
+            return output
+        if payload.get("declined") is True:
+            return DECLINED_NOTE
+        answer = payload.get("answer")
+        if isinstance(answer, str) and answer.strip():
+            return f"You answered: {answer.strip()}"
+        if isinstance(payload.get("parts"), list) and payload["parts"]:
+            return "You answered with a picture."
+        return output
+
+
+def _ask_payload(output: str) -> Mapping[str, object] | None:
+    """Return the payload of an ``ask_user`` result, or ``None`` when the text is not one."""
+    try:
+        result = json.loads(output)
+    except ValueError:
+        return None
+    payload = result.get("payload") if isinstance(result, Mapping) else None
+    return payload if isinstance(payload, Mapping) else None
+
+
 class TodoTool(ToolHandler):
     """``todo_write``: a plan, so the number of steps is the story."""
 
@@ -645,6 +699,8 @@ DEFAULT_RENDERERS = Renderers(
         DeleteTool(),
         ShellTool(),
         SearchTool(),
+        WebSearchTool(),
+        AskUserTool(),
         TodoTool(),
         SkillTool(),
         TaskTool(),

{zettcode-0.1.9 → zettcode-0.1.10}/src/zettcode/app/agent/conversation/replay.py

@@ -19,6 +19,7 @@ from zett_agent.messages import AnyMessage, AssistantMessage, SystemMessage, Too
 
 from zettcode.config import DEFAULT_TRANSCRIPT_MAX_ENTRIES
 
+from ..dialogue.ask import declined_answer
 from ..dialogue.relay import relay_of
 from ..dialogue.side import is_side_line
 from ..extensions.usage import UsageSnapshot
@@ -26,6 +27,7 @@ from ..storage import MessageLine, Session
 from .entries import EntryStatus
 from .presenters import DEFAULT_PRESENTERS, Presenters
 from .rendering import DEFAULT_RENDERERS, Renderers
+from .server_tools import ServerToolRun, answer_after_tools, describe_output, runs_in_blocks
 from .stops import stop_text
 from .transcript import Transcript
 
@@ -75,7 +77,13 @@ def entries_added_by(message: AnyMessage) -> int:
             return 1
         case AssistantMessage():
             stopped = message.stop is not None and not message.stop.ok
-            return bool(message.reasoning) + bool(message.content) + len(message.tool_calls) + stopped
+            return (
+                bool(message.reasoning)
+                + bool(message.content)
+                + len(message.tool_calls)
+                + len(runs_in_blocks(message.replay_blocks))
+                + stopped
+            )
         case _:
             return 0
 
@@ -152,7 +160,26 @@ def replay(
             case AssistantMessage():
                 if message.reasoning:
                     transcript.restore_thinking(message.reasoning, line.timing.reasoning_duration_ns)
-                if message.content:
+                runs = runs_in_blocks(message.replay_blocks)
+
+                def hosted(rows: Sequence[ServerToolRun] = runs) -> None:
+                    """Add the rows of the tools the endpoint ran, each closed by its own result."""
+                    for run in rows:
+                        transcript.start_tool(run.call_id, run.name, run.arguments)
+                        transcript.complete_tool(
+                            run.call_id,
+                            describe_output(run),
+                            status=EntryStatus.FAILED if run.error else EntryStatus.COMPLETED,
+                            wait=False,
+                        )
+
+                # A hosted tool has no message of its own: its call and result are both in the answer's blocks, kept
+                # because the provider needs them back. Where the answer's text sits in those blocks is where the row
+                # goes relative to it, so a reopened session reads in the order the run did.
+                if not answer_after_tools(message.replay_blocks) and message.content:
+                    transcript.append_answer(message.content)
+                hosted()
+                if answer_after_tools(message.replay_blocks) and message.content:
                     transcript.append_answer(message.content)
                 for call in message.tool_calls:
                     transcript.start_tool(call.id, call.name, call.arguments)
@@ -160,6 +187,9 @@ def replay(
                     transcript.error(stop_text(message.stop))
             case ToolMessage():
                 status = EntryStatus.COMPLETED if message.success else EntryStatus.FAILED
+                if message.name == "ask_user" and declined_answer(message.text):
+                    # A cancelled question is an answer of its own, not a failure.
+                    status = EntryStatus.SKIPPED
                 transcript.complete_tool(message.tool_call_id, message.text, status=status, wait=False)
             case _:
                 continue

zettcode-0.1.10/src/zettcode/app/agent/conversation/server_tools.py

@@ -0,0 +1,157 @@
+"""What a provider-run tool left behind: the rows for a hosted search, live and replayed.
+
+A hosted tool is not called by the agent: the endpoint runs it, and the framework reports the call and its result as
+events. Those events are not messages, so the store never sees them; but the provider's own blocks are kept as the
+answer's opaque ``replay_blocks``, which the store writes and reads back. This module is the one place that turns
+either of those into the words of a row, so a resumed session shows what the live one showed.
+
+The result of a search is a list of pages, each with a title, a URL and an opaque encrypted payload that must never be
+put in front of the reader or sent back in a prompt as text: only the title and the URL are shown here.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+#: The most pages one row lists. A row is a note that a search happened, not the search's own page.
+MAX_RESULTS = 5
+
+#: Result blocks whose payload is the provider's own and is never shown as text.
+_SEARCH_RESULT_TYPES = frozenset({"web_search_result", "search_result"})
+
+#: Block types that record a hosted call rather than text.
+_CALL_TYPES = frozenset({"server_tool_use"})
+
+
+@dataclass(frozen=True, slots=True)
+class ServerToolRun:
+    """One hosted tool call as the transcript needs it.
+
+    Attributes:
+        call_id: The provider's identifier for the call.
+        name: The tool's name, such as ``web_search``.
+        arguments: What it was asked, when the provider said; ``{"query": ...}`` for a search.
+        output: What it returned, as the provider reported it.
+        error: The provider's error code when the tool failed.
+    """
+
+    call_id: str
+    name: str
+    arguments: Mapping[str, Any]
+    output: Any = None
+    error: str | None = None
+
+
+def _results_in(output: Any) -> list[Mapping[str, Any]]:
+    """Return the page blocks of a search result, wherever the provider put them.
+
+    The adapter hands a hosted tool's output over as the block's own ``content``: a list of pages for a search, with
+    the provider's encrypted payload beside each title and URL.
+    """
+    match output:
+        case bool() | str() | int() | float() | None:
+            return []
+        case Mapping():
+            content = output.get("content")
+            if isinstance(content, Iterable) and not isinstance(content, str):
+                return [item for item in content if isinstance(item, Mapping)]
+            if output.get("type") in _SEARCH_RESULT_TYPES:
+                return [output]
+            return []
+        case Iterable():
+            return [item for item in output if isinstance(item, Mapping)]
+        case _:
+            return []
+
+
+def describe_search(output: Any) -> str:
+    """Return a search result as the few lines a row shows: how many pages, and which.
+
+    Only a page's title and URL are shown; the encrypted payload the provider returns beside them is its own business
+    and is neither printed nor kept.
+    """
+    pages = _results_in(output)
+    if not pages:
+        return "No pages"
+    lines = [f"{len(pages)} page{'s' if len(pages) != 1 else ''}"]
+    for page in pages[:MAX_RESULTS]:
+        title = page.get("title")
+        url = page.get("url")
+        named = title.strip() if isinstance(title, str) and title.strip() else ""
+        address = url.strip() if isinstance(url, str) and url.strip() else ""
+        lines.append(f"- {named} \u2014 {address}" if named and address else f"- {named or address}")
+    if len(pages) > MAX_RESULTS:
+        lines.append(f"\u2026 and {len(pages) - MAX_RESULTS} more")
+    return "\n".join(lines)
+
+
+def describe_output(run: ServerToolRun) -> str:
+    """Return what one hosted tool said, in the words of its own kind."""
+    if run.error:
+        return run.error
+    if run.name == "web_search" or _results_in(run.output):
+        return describe_search(run.output)
+    # Another provider's hosted tool: its payload is already text or a plain structure.
+    return run.output if isinstance(run.output, str) else ""
+
+
+def runs_in_blocks(blocks: Iterable[Mapping[str, Any]]) -> list[ServerToolRun]:
+    """Return the hosted tool calls one answer's ``replay_blocks`` record, results paired with their calls.
+
+    A block that is not a hosted call is skipped: a thinking block, or the answer's text. A call whose result is not
+    in the same answer keeps an empty output, which reads as a search that said nothing.
+    """
+    calls: dict[str, ServerToolRun] = {}
+    order: list[str] = []
+    for block in blocks:
+        match block.get("type"):
+            case "server_tool_use":
+                call_id = block.get("id")
+                name = block.get("name")
+                if not isinstance(call_id, str) or not isinstance(name, str):
+                    continue
+                call_input = block.get("input")
+                arguments = dict(call_input) if isinstance(call_input, Mapping) else {}
+                calls[call_id] = ServerToolRun(call_id, name, arguments)
+                order.append(call_id)
+            case "web_search_tool_result" | "server_tool_result" | "web_fetch_tool_result":
+                found = block.get("tool_use_id") or block.get("call_id")
+                if not isinstance(found, str) or found not in calls:
+                    continue
+                error = block.get("error_code")
+                calls[found] = ServerToolRun(
+                    found,
+                    calls[found].name,
+                    calls[found].arguments,
+                    output=block,
+                    error=str(error) if isinstance(error, str) and error else None,
+                )
+    return [calls[call_id] for call_id in order]
+
+
+def answer_after_tools(blocks: Iterable[Mapping[str, Any]]) -> bool:
+    """Return whether the answer's text came after its hosted tool, as the provider streamed them.
+
+    Anthropic runs a hosted search before it writes the answer, so the row belongs above it; a provider that writes
+    first and searches after (DeepSeek does, when it announces the search) has it below. The blocks record which.
+    """
+    first_tool: int | None = None
+    for index, block in enumerate(blocks):
+        kind = block.get("type")
+        if first_tool is None and kind in _CALL_TYPES:
+            first_tool = index
+        elif kind == "text" and isinstance(block.get("text"), str) and block["text"].strip():
+            return first_tool is not None
+    return False
+
+
+__all__ = [
+    "MAX_RESULTS",
+    "ServerToolRun",
+    "answer_after_tools",
+    "describe_output",
+    "describe_search",
+    "runs_in_blocks",
+]

{zettcode-0.1.9 → zettcode-0.1.10}/src/zettcode/app/agent/conversation/text.py

@@ -45,6 +45,9 @@ PROCESSING = "Processing"
 #: reserved for it.
 STOP_HINT = "^C/Esc to interrupt"
 
+#: What the row of a question the reader cancelled says under its title.
+DECLINED_NOTE = "You declined; the model was told and carries on."
+
 # Matches both escape families a tool can smuggle into its output: CSI
 # (``ESC [`` parameters and a final byte) and OSC (``ESC ]`` up to BEL or ST).
 # Stripping them keeps a coloured compiler message from repainting the canvas.

{zettcode-0.1.9 → zettcode-0.1.10}/src/zettcode/app/agent/conversation/tips.py

@@ -15,6 +15,8 @@ from __future__ import annotations
 import random
 from collections.abc import Callable, MutableSequence, Sequence
 
+from zettcode.tui import OPTION
+
 #: What the reader may be told, in the words they will see.
 TIPS: tuple[str, ...] = (
     "Type while it works: your message can steer this request, or wait and follow it.",
@@ -35,6 +37,7 @@ TIPS: tuple[str, ...] = (
     "Ctrl-R searches what you have sent before; Up recalls the last message.",
     "Ctrl-V attaches an image from the clipboard, for a model that takes images.",
     "Page Up scrolls the conversation, and Esc jumps back to the newest line.",
+    f"{OPTION.capitalize()}-\u2191/\u2193 (or Ctrl-\u2191/\u2193) jumps to the previous or next message you sent.",
     "Drag in the conversation to copy text. Hold Shift or Alt to use your terminal's own selection.",
     "Put project instructions in AGENTS.md and they are given to the model with every request.",
     "A SKILL.md in ~/.zettcode/skills teaches ZettCode a job it can repeat.",
@@ -44,7 +47,7 @@ TIPS: tuple[str, ...] = (
     "/self-compact lets the model decide for itself when to compact this session.",
     "zettcode resume <id> opens a stored session; zettcode update installs the newest release.",
     "zettcode doctor checks every configured model from a shell, with no session started.",
-    "zettcode --auto runs shell commands without asking for that run; /permission can change it later.",
+    "zettcode --full skips every shell question and the sandbox for that run; /permission can change it later.",
     "Press Esc to stop a request; /continue picks it up again where it left off.",
     "A plugin is a Python package: install it and ZettCode gains its commands, tools, themes or pets.",
     "These tips can be turned off: tips = false under [transcript] in the configuration.",

{zettcode-0.1.9 → zettcode-0.1.10}/src/zettcode/app/agent/conversation/transcript/stream.py

@@ -128,6 +128,24 @@ class StreamMixin(TurnMixin):
         # tool's business and this opens every one the same way.
         self._add(self.renderers.open_tool(name, arguments, id=self._next_id, call_id=call_id, started_at=self.clock()))
 
+    def restate_tool(self, call_id: str, arguments: Mapping[str, object]) -> None:
+        """Phrase a row again with arguments that arrived after it opened.
+
+        A hosted tool's input may stream in fragments after the call started, so the row opens knowing only the tool's
+        name. This is where the query it really ran appears, before the row is closed.
+
+        Args:
+            call_id: Identifier the matching result will carry.
+            arguments: What the call turned out to be, which the chain phrases.
+        """
+        entry = next(
+            (item for item in reversed(self.entries) if isinstance(item, ToolEntry) and item.call_id == call_id), None
+        )
+        if entry is None:
+            return
+        entry.title = self.renderers.describe(entry.tool, arguments).title
+        self._changed(entry)
+
     def complete_tool(
         self, call_id: str, output: str, *, status: EntryStatus = EntryStatus.COMPLETED, wait: bool = True
     ) -> None:

{zettcode-0.1.9 → zettcode-0.1.10}/src/zettcode/app/agent/dialogue/ask.py

@@ -8,6 +8,7 @@ panel never reads a raw payload and the agent never invents one.
 
 from __future__ import annotations
 
+import json
 from dataclasses import dataclass
 from typing import Any
 
@@ -19,6 +20,7 @@ __all__ = [
     "AskUserQuestion",
     "answer_payload",
     "decline_payload",
+    "declined_answer",
     "question_from",
 ]
 
@@ -94,3 +96,18 @@ def decline_payload(question: AskUserQuestion) -> dict[str, Any]:
         "declined": True,
         "reason": "the user cancelled the question",
     }
+
+
+def declined_answer(text: str) -> bool:
+    """Return whether a tool result is the one a cancelled question leaves behind.
+
+    The tool answers with the payload the shell sent, serialized as JSON. A cancelled question carries
+    ``"declined": true`` and no answer; a row that has one is not a row that failed, it is a question nobody
+    needed to answer, and the transcript says so.
+    """
+    try:
+        result = json.loads(text)
+    except ValueError:
+        return False
+    payload = result.get("payload") if isinstance(result, dict) else None
+    return isinstance(payload, dict) and payload.get("declined") is True