nanocode-cli 0.2.7__tar.gz → 0.2.8__tar.gz

{nanocode_cli-0.2.7/nanocode_cli.egg-info → nanocode_cli-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.2.7
+Version: 0.2.8
 Summary: A lightweight terminal-based AI coding assistant
 Author-email: hit9 <hit9@icloud.com>
 License-Expression: BSD-3-Clause
@@ -21,6 +21,7 @@ Classifier: Topic :: Terminals
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: json-repair>=0.39
 Requires-Dist: prompt-toolkit>=3.0
 Requires-Dist: typing-extensions>=4.7
 Provides-Extra: dev
@@ -76,6 +77,7 @@ export NANOCODE_DIR=".nanocode"
 export NANOCODE_TEMPERATURE="0.7"
 export NANOCODE_REASONING="on"
 export NANOCODE_REASONING_EFFORT="medium"
+export NANOCODE_STREAM="on"
 export NANOCODE_MODEL_TIMEOUT="60"
 export NANOCODE_SHELL_TIMEOUT="60"
 export NANOCODE_COMPACT_AT="100"

{nanocode_cli-0.2.7 → nanocode_cli-0.2.8}/README.md

@@ -46,6 +46,7 @@ export NANOCODE_DIR=".nanocode"
 export NANOCODE_TEMPERATURE="0.7"
 export NANOCODE_REASONING="on"
 export NANOCODE_REASONING_EFFORT="medium"
+export NANOCODE_STREAM="on"
 export NANOCODE_MODEL_TIMEOUT="60"
 export NANOCODE_SHELL_TIMEOUT="60"
 export NANOCODE_COMPACT_AT="100"

{nanocode_cli-0.2.7 → nanocode_cli-0.2.8}/nanocode.py

@@ -11,6 +11,7 @@ import fnmatch
 import hashlib
 import itertools
 import json
+import json_repair
 import os
 import platform
 import re
@@ -41,7 +42,7 @@ from prompt_toolkit.patch_stdout import patch_stdout
 
 JsonValue: TypeAlias = Any
 Json: TypeAlias = dict[str, JsonValue]
-__version__ = "0.2.7"
+__version__ = "0.2.8"
 
 
 class Error(Exception): ...
@@ -350,14 +351,23 @@ class RangeFingerprintStore:
         if current_fingerprint == fingerprint:
             return self.Resolved(start=resolved_start, end=resolved_end, fingerprint=current_fingerprint)
 
-        matches = self._find_matches(lines, filepath=filepath, start=start, end=end, fingerprint=fingerprint)
+        for content in self._candidate_contents(
+            filepath=filepath,
+            start=resolved_start,
+            end=resolved_end,
+            fingerprint=fingerprint,
+        ):
+            if _range_fingerprint(content) == current_fingerprint:
+                return self.Resolved(start=resolved_start, end=resolved_end, fingerprint=current_fingerprint)
+
+        matches = self._find_matches(lines, filepath=filepath, start=resolved_start, end=resolved_end, fingerprint=fingerprint)
         message = (
             f"fingerprint mismatch for range {start}:{end}: expected {fingerprint}, current {current_fingerprint}; "
             f"call Read(filepath, {start}, {end}) and reuse that range fingerprint"
         )
         other_ranges = self._ranges_for_fingerprint(filepath=filepath, fingerprint=fingerprint)
         if other_ranges:
-            message += "; this fingerprint was cached for exact range(s): " + ", ".join(f"{range_start}:{range_end}" for range_start, range_end in other_ranges)
+            message += "; this fingerprint was cached for range(s): " + ", ".join(f"{range_start}:{range_end}" for range_start, range_end in other_ranges)
         if not matches:
             raise ToolCallError(message)
         if len(matches) > 1:
@@ -366,18 +376,16 @@ class RangeFingerprintStore:
         return self.Resolved(
             start=relocated_start,
             end=relocated_end,
-            fingerprint=fingerprint,
+            fingerprint=_range_fingerprint("".join(lines[relocated_start:relocated_end])),
             relocated_from=(resolved_start, resolved_end),
         )
 
     def _find_matches(self, lines: list[str], *, filepath: str, start: int, end: int, fingerprint: str) -> list[tuple[int, int]]:
-        filepath = os.path.realpath(filepath)
-        contents = []
-        for entry in self._entries:
-            if entry.fingerprint != fingerprint or entry.filepath != filepath or entry.start != start or entry.end != end or not entry.content:
-                continue
-            if entry.content not in contents:
-                contents.append(entry.content)
+        contents = [
+            content
+            for content in self._candidate_contents(filepath=filepath, start=start, end=end, fingerprint=fingerprint)
+            if content
+        ]
 
         matches = []
         for content in contents:
@@ -392,6 +400,25 @@ class RangeFingerprintStore:
                         return matches
         return matches
 
+    def _candidate_contents(self, *, filepath: str, start: int, end: int, fingerprint: str) -> list[str]:
+        filepath = os.path.realpath(filepath)
+        contents: list[str] = []
+        for entry in self._entries:
+            if entry.fingerprint != fingerprint or entry.filepath != filepath:
+                continue
+            if start == end:
+                if entry.start == start and entry.end == end and entry.content == "":
+                    contents.append("")
+                continue
+            entry_lines = entry.content.splitlines(keepends=True)
+            cached_end = entry.start + len(entry_lines)
+            if start < entry.start or end > cached_end:
+                continue
+            candidate = "".join(entry_lines[start - entry.start : end - entry.start])
+            if candidate not in contents:
+                contents.append(candidate)
+        return contents
+
     def _ranges_for_fingerprint(self, *, filepath: str, fingerprint: str) -> list[tuple[int, int]]:
         filepath = os.path.realpath(filepath)
         ranges = []
@@ -427,6 +454,7 @@ class Session:
     temperature: float = field(default_factory=lambda: float(os.environ.get("NANOCODE_TEMPERATURE", "0.7")))
     reasoning: bool = field(default_factory=lambda: os.environ.get("NANOCODE_REASONING", "on") == "on")
     reasoning_effort: str = field(default_factory=lambda: os.environ.get("NANOCODE_REASONING_EFFORT", "medium"))
+    stream: bool = field(default_factory=lambda: os.environ.get("NANOCODE_STREAM", "on") == "on")
     model_timeout: int = field(default_factory=lambda: int(os.environ.get("NANOCODE_MODEL_TIMEOUT", "60")))
     shell_timeout: int = field(default_factory=lambda: int(os.environ.get("NANOCODE_SHELL_TIMEOUT", "60")))
     compact_at: int = field(default_factory=lambda: int(os.environ.get("NANOCODE_COMPACT_AT", "100")))
@@ -546,6 +574,7 @@ ConfirmationResult: TypeAlias = bool | str
 ConfirmCallback: TypeAlias = Callable[[ParsedToolCall, Tool], ConfirmationResult]
 ToolDisplayCallback: TypeAlias = Callable[[ParsedToolCall, Tool], None]
 MessageCallback: TypeAlias = Callable[[str], None]
+ActionCallback: TypeAlias = Callable[[Json], None]
 StatusAction: TypeAlias = Callable[[], str]
 StatusRunner: TypeAlias = Callable[[StatusAction], str]
 
@@ -607,7 +636,7 @@ class ReadTool(Tool):
             "Optional range is 0-based [start,end); end=0 means EOF.",
             "Returns at most 1000 lines; truncated results include total lines and next-step guidance.",
             "Prefer Search before Read for large or unknown files; use bounded reads when exact context is needed.",
-            "For ReplaceRange, the fingerprint is valid only for this exact filepath/start/end; read the exact edit range immediately before replacing.",
+            "For ReplaceRange, non-empty subranges may use a wider cached Read fingerprint that covers them; empty insert ranges require an exact empty-range Read.",
         ]
 
     @classmethod
@@ -850,11 +879,12 @@ class SearchTool(Tool):
 
     @classmethod
     def signature(cls) -> str:
-        return "Search(pattern, path[, option...]) -> SearchToolResult<matches>; option is context=N|N (0..30) or glob_pattern"
+        return "Search(pattern[, path][, option...]) -> SearchToolResult<matches>; option is context=N|N (0..30) or glob_pattern"
 
     @classmethod
     def example(cls) -> list[str]:
         return [
+            'Example args: ["TODO"]',
             'Example args: ["class Foo", "code.py"]',
             'Example args: ["TODO", ".", "*.py"]',
             'Example args: ["class Bar|def main", "nanocode.py", "context=6"]',
@@ -864,8 +894,8 @@ class SearchTool(Tool):
 
     @classmethod
     def make(cls, session: Session, args: list[str]) -> Self:
-        if len(args) not in (2, 3, 4):
-            raise ToolCallError("requires 2 to 4 args: pattern, path[, glob_pattern][, context=N]")
+        if len(args) not in (1, 2, 3, 4):
+            raise ToolCallError("requires 1 to 4 args: pattern[, path][, glob_pattern][, context=N]")
         raw_pattern = str(args[0])
         if not raw_pattern:
             raise ToolCallError("pattern cannot be empty")
@@ -875,6 +905,9 @@ class SearchTool(Tool):
             raise ToolCallError("pattern cannot be empty")
         if regex and "\n" in pattern:
             raise ToolCallError("multiline regex is not supported; Search is line-oriented. Search each line separately or Read a nearby range.")
+        target_path_arg = str(args[1]) if len(args) >= 2 else "."
+        if not target_path_arg:
+            target_path_arg = "."
         glob_pattern = ""
         context_lines = cls.CONTEXT_LINES
         for raw_option in args[2:]:
@@ -904,7 +937,7 @@ class SearchTool(Tool):
             pattern=raw_pattern,
             patterns=patterns,
             regex=regex,
-            target_path=session.resolve_path(args[1]),
+            target_path=session.resolve_path(target_path_arg),
             glob_pattern=glob_pattern,
             context_lines=context_lines,
             cwd=session.cwd,
@@ -1205,8 +1238,8 @@ class ReplaceRangeTool(Tool):
     @classmethod
     def description(cls) -> list[str]:
         return [
-            "Replace one 0-based line range when its fingerprint comes from Read(filepath, exact same start, exact same end).",
-            "Never use a wider Read fingerprint for a narrower edit; if mismatch happens, Read the exact target range and retry once.",
+            "Replace one 0-based line range when its fingerprint comes from Read(filepath, ...).",
+            "If a wider cached Read range covers this target range, the tool may slice and validate the narrower range automatically; otherwise Read the exact target range and retry once.",
             "If earlier edits shifted lines, a cached Read fingerprint for the same original range can relocate only when old content still matches exactly once.",
         ]
 
@@ -1314,7 +1347,7 @@ class BatchReplaceRangesTool(Tool):
         return [
             "Replace multiple 0-based line ranges in one file against one snapshot.",
             "Use this for multiple edits in the same file; earlier edits in this call do not shift later ranges.",
-            "Each edit fingerprint must come from Read(filepath, exact same start, exact same end); never reuse a wider Read fingerprint for a narrower edit.",
+            "Each edit fingerprint must come from Read(filepath, ...); if a wider cached range covers the target range, it may be sliced and validated automatically.",
             "Same-range cached fingerprints can relocate shifted old content.",
         ]
 
@@ -1465,7 +1498,7 @@ class ApplyPatchTool(Tool):
         try:
             with open(self.filepath, "r", encoding="utf-8") as f:
                 original = f.read()
-            new_content, _ = self._apply_unified_diff(original, self.unified_diff)
+            new_content, _ = self._apply_unified_diff(original, self._normalized_unified_diff())
         except (OSError, ToolCallError) as error:
             return label + "\n# preview unavailable: " + str(error)
         return _make_unified_diff(original, new_content, self.filepath) or label
@@ -1473,7 +1506,7 @@ class ApplyPatchTool(Tool):
     def call(self) -> str:
         with open(self.filepath, "r", encoding="utf-8") as f:
             original = f.read()
-        new_content, hunks = self._apply_unified_diff(original, self.unified_diff)
+        new_content, hunks = self._apply_unified_diff(original, self._normalized_unified_diff())
         if new_content == original:
             raise ToolCallError("patch produced no changes")
         with open(self.filepath, "w", encoding="utf-8") as f:
@@ -1488,6 +1521,58 @@ class ApplyPatchTool(Tool):
             ]
         )
 
+    def _normalized_unified_diff(self) -> str:
+        lines = self.unified_diff.splitlines(keepends=True)
+        begin_index = next((index for index, line in enumerate(lines) if line.strip()), -1)
+        if begin_index < 0 or lines[begin_index].strip() != "*** Begin Patch":
+            return self.unified_diff
+        return self._codex_update_patch_to_unified_diff(lines, begin_index)
+
+    def _codex_update_patch_to_unified_diff(self, lines: list[str], begin_index: int) -> str:
+        update_seen = False
+        end_seen = False
+        hunk_lines: list[str] = []
+        for line in lines[begin_index + 1 :]:
+            stripped = line.strip()
+            if stripped == "*** End Patch":
+                end_seen = True
+                break
+            if stripped.startswith("*** Update File: "):
+                if update_seen:
+                    raise ToolCallError("ApplyPatch supports one Update File per call")
+                self._validate_codex_patch_path(stripped[len("*** Update File: ") :].strip())
+                update_seen = True
+                continue
+            if stripped.startswith(("*** Add File:", "*** Delete File:", "*** Move to:")):
+                raise ToolCallError("ApplyPatch supports only Update File patches")
+            if stripped == "*** End of File":
+                continue
+            if not update_seen:
+                if stripped:
+                    raise ToolCallError("invalid ApplyPatch wrapper")
+                continue
+            hunk_lines.append(self._normalize_codex_hunk_header(line))
+        if not update_seen:
+            raise ToolCallError("ApplyPatch wrapper missing Update File")
+        if not end_seen:
+            raise ToolCallError("ApplyPatch wrapper missing End Patch")
+        return "".join(hunk_lines)
+
+    def _validate_codex_patch_path(self, patch_path: str) -> None:
+        if not patch_path:
+            raise ToolCallError("ApplyPatch wrapper missing Update File path")
+        candidate = patch_path if os.path.isabs(patch_path) else os.path.join(self.cwd, patch_path)
+        if os.path.realpath(candidate) != os.path.realpath(self.filepath):
+            raise ToolCallError("patch target does not match filepath: " + patch_path)
+
+    @staticmethod
+    def _normalize_codex_hunk_header(line: str) -> str:
+        body = line.rstrip("\r\n")
+        newline = line[len(body) :]
+        if body.startswith("@@ ") and not body.startswith("@@ -"):
+            return "@@" + newline
+        return line
+
     @staticmethod
     def _apply_unified_diff(content: str, unified_diff: str) -> tuple[str, int]:
         lines = content.splitlines(keepends=True)
@@ -1813,17 +1898,20 @@ Core:
 - Follow the plan, but revise it when facts require it.
 
 Tools:
-- MUST use JSON tool_calls. Do not use native <tool_call>Tool(args...) syntax.
-- Use multiple tool calls in one turn when they are independent.
+- MUST use tool actions. Do not use native <tool_call>Tool(args...) syntax.
+- Keep each tool batch small: never more than 5 tool actions unless the user explicitly asked for broad parallel work.
+- Use multiple tool calls in one turn only when they are independent and do not require seeing another tool's result first.
+- If you need discovery (ListDir/Search/Read/LineCount), do only the necessary discovery batch, then stop and wait for results before editing, patching, testing, or cleanup.
+- Do not queue speculative follow-up tools whose arguments depend on unread files, unknown search results, or unverified command output.
 - Prefer specific tools first; use Bash only when no provided tool fits.
 - Prefer Search before Read when locating code or facts; Read only known small ranges or exact files needed for editing.
 - Read returns at most 1000 lines; if truncated, use Search or smaller Read ranges in batches.
-- ReplaceRange/BatchReplaceRanges fingerprints are valid only for the exact filepath/start/end returned by Read. Never use a wider Read fingerprint for a narrower edit. If fingerprint mismatch happens, immediately Read the exact target range and retry once.
-- Summarize every latest tool result in last_tool_calls_summaries; raw results are shown once only, so include key_evidence when paths, lines, errors, or decisions matter later.
+- ReplaceRange/BatchReplaceRanges may use a wider cached Read fingerprint for a non-empty subrange that it covers. Empty insert ranges require an exact empty-range Read. If fingerprint mismatch happens, immediately Read the exact target range and retry once.
+- Summarize every latest tool result with tool_summary actions; raw results are shown once only, so include key_evidence when paths, lines, errors, or decisions matter later.
 - Latest tool results are already shown in Latest_Tool_Call_Results; use result_file logs only as a fallback when needed.
 - If an older tool result lacks detail that is needed for the task, prefer re-running a targeted source tool; Read result_file logs only when that is the cheapest accurate source.
-- known_append is stable memory; current_context_update is task-local memory.
-- tool_call.intention must state the question to answer, not just the action.
+- known actions are stable memory; context actions are task-local memory.
+- tool action intention must state the question to answer, not just the action.
 
 Verification:
 - Verification_State belongs only to its <goal>.
@@ -1844,77 +1932,40 @@ Input:
 - Latest_User_Input: latest user message
 - Tools: available tool specs
 
-Output MUST be exactly one JSON object.
-No markdown, prose, code fences, XML tags, native tool calls, or text outside JSON.
-Put normal replies in message_to_user.
-Put tool calls only in JSON tool_calls.
-
-Schema:
+Output format is mandatory:
+- Output action frames only.
+- Each action frame MUST contain exactly one JSON object action.
+- Each action frame MUST end with a separator line containing only __END_ACTION__.
+- The separator is required after every action, including the final action.
+- Pretty-printed multi-line JSON is allowed inside a frame.
+- Do not wrap actions in {"actions":[...]}.
+- Do not output a JSON array.
+- Do not output markdown, prose, code fences, XML tags, native tool calls, or text outside action frames.
+- Include only actions that are needed; do not emit null/no-op fields.
+
+Action schemas:
+{"type": "message", "text": "string"}
+{"type": "tool", "name": "string", "intention": "string", "args": ["string"]}
+{"type": "tool_summary", "tool": "string", "intention": "string", "outcome": "success|failure|partial", "summary": "string", "key_evidence": null | ["string"], "result_file": null | "string", "needs_raw_read": true | false}
+{"type": "goal", "text": "string"}
+{"type": "plan", "mode": "replace|patch", "items": [{"op": "add|update|remove", "id": "string", "after": null | "string", "text": null | "string", "status": null | "todo|doing|done|blocked", "evidence": null | "string"}]}
+{"type": "known", "items": [{"fact": "string", "details": null | ["string"]}]}
+{"type": "context", "mode": "replace|append", "items": [{"note": "string", "details": null | ["string"]}]}
+{"type": "verify", "method": null | "string", "status": "pending|passed|blocked", "evidence": null | "string"}
+
+Example:
+{
+  "type": "tool",
+  "name": "Read",
+  "intention": "Inspect SearchTool.make.",
+  "args": ["nanocode.py", "880", "930"]
+}
+__END_ACTION__
 {
-  "user_language": "string",
-
-  "goal_update": null | "string",
-  "goal_reached": true | false,
-
-  "plan_update": null | {
-    "mode": "replace" | "patch",
-    "items": [
-      {
-        "op": "add|update|remove",
-        "id": "string",
-        "after": null | "string",
-        "text": null | "string",
-        "status": null | "todo|doing|done|blocked",
-        "evidence": null | "string"
-      }
-    ]
-  },
-
-  "known_append": null | [
-    {
-      "fact": "string",
-      "details": null | ["string"]
-    }
-  ],
-
-  "current_context_update": null | {
-    "mode": "replace" | "append",
-    "items": [
-      {
-        "note": "string",
-        "details": null | ["string"]
-      }
-    ]
-  },
-
-  "verification": {
-    "method": null | "string",
-    "status": "pending" | "passed" | "blocked",
-    "evidence": null | "string"
-  },
-
-  "tool_calls": null | [
-    {
-      "name": "string",
-      "intention": "string",
-      "args": ["string"]
-    }
-  ],
-
-  "last_tool_calls_summaries": [
-    {
-      "tool": "string",
-      "intention": "string",
-      "outcome": "success" | "failure" | "partial",
-      "summary": "string",
-      "key_evidence": null | ["string"],
-      "result_file": null | "string",
-      "needs_raw_read": true | false
-    }
-  ],
-
-  "message_to_user": null | "string"
+  "type": "message",
+  "text": "Done."
 }
+__END_ACTION__
 """
 
 MAIN_AGENT_USER_PROMPT_TEMPLATE = """
@@ -2059,10 +2110,14 @@ class PromptBuilder:
 
 @final
 class ModelClient:
+    ACTION_FRAME_END: ClassVar[str] = "__END_ACTION__"
+    ACTION_FRAME_END_PATTERN: ClassVar[re.Pattern[str]] = re.compile(r"^\s*\**_*\s*END[\s_-]*ACTION\s*_*\**\s*$", re.IGNORECASE)
+    ACTION_FRAME_END_SPLIT_PATTERN: ClassVar[re.Pattern[str]] = re.compile(r"\**_*\s*END[\s_-]*ACTION\s*_*\**", re.IGNORECASE)
+
     def __init__(self, session: Session):
         self.session = session
 
-    def request(self, system_prompt: str, user_prompt: str, *, activity: str = "main") -> Json:
+    def request(self, system_prompt: str, user_prompt: str, *, activity: str = "main", on_action: ActionCallback | None = None) -> Json:
         if not self.session.api_url:
             raise LLMError("NANOCODE_API_URL is required")
         if not self.session.api_key:
@@ -2078,8 +2133,10 @@ class ModelClient:
             "model": self.session.model,
             "messages": messages,
             "temperature": self.session.temperature,
-            "response_format": {"type": "json_object"},
         }
+        if self.session.stream:
+            payload["stream"] = True
+            payload["stream_options"] = {"include_usage": True}
         extra_params = self._reasoning_params()
         payload.update(extra_params)
         self._write_debug_prompt(activity=activity, messages=messages)
@@ -2096,7 +2153,11 @@ class ModelClient:
             self.session.current_model_call_started_at = time.monotonic()
             try:
                 with urllib.request.urlopen(request, timeout=self.session.model_timeout) as response:
-                    body = response.read().decode("utf-8")
+                    if self.session.stream:
+                        content, usage = self._read_streaming_content(response, on_action=on_action)
+                        result: Json = {"usage": usage}
+                    else:
+                        body = response.read().decode("utf-8")
             finally:
                 self.session.current_model_call_started_at = 0.0
         except socket.timeout:
@@ -2107,17 +2168,57 @@ class ModelClient:
         except Exception as error:
             raise LLMError(str(error))
 
-        try:
-            result = json.loads(body)
-        except json.JSONDecodeError:
-            raise LLMError("API response is not JSON: " + _shorten(body))
+        if not self.session.stream:
+            try:
+                result = json.loads(body)
+            except json.JSONDecodeError:
+                raise LLMError("API response is not JSON: " + _shorten(body))
 
         self._record_usage(_json_dict(result.get("usage") if isinstance(result, dict) else None))
-        content = self._message_content(result)
+        if not self.session.stream:
+            content = self._message_content(result)
         if content is None:
             return self._invalid_model_response(self._format_missing_message_content(result))
         return self._parse_model_content(content)
 
+    def _read_streaming_content(self, response: Any, *, on_action: ActionCallback | None = None) -> tuple[str, Json]:
+        parts: list[str] = []
+        usage: Json = {}
+        buffer = ""
+        frame_number = 0
+        for raw_line in response:
+            line = raw_line.decode("utf-8", errors="replace").strip()
+            if not line or line.startswith(":") or not line.startswith("data:"):
+                continue
+            data = line[len("data:") :].strip()
+            if data == "[DONE]":
+                break
+            try:
+                event = json.loads(data)
+            except json.JSONDecodeError:
+                continue
+            event_data = _json_dict(event)
+            event_usage = _json_dict(event_data.get("usage"))
+            if event_usage:
+                usage = event_usage
+            choices = _json_list(event_data.get("choices"))
+            if not choices:
+                continue
+            delta = _json_dict(_json_dict(choices[0]).get("delta"))
+            content = delta.get("content")
+            if not isinstance(content, str):
+                continue
+            parts.append(content)
+            if on_action is not None:
+                buffer += content
+                frames, buffer = self._completed_action_frames(buffer)
+                for frame in frames:
+                    frame_number += 1
+                    action, _error = self._parse_action_frame(frame, frame_number)
+                    if action is not None:
+                        on_action(action)
+        return "".join(parts), usage
+
     def _write_debug_prompt(self, *, activity: str, messages: list[Json]) -> str:
         if not self.session.debug:
             return ""
@@ -2148,13 +2249,79 @@ class ModelClient:
         text = self._strip_leaked_think_tags(text)
         text = self._strip_json_fence(text)
         text = self._strip_leaked_think_tags(text)
+        actions: list[Json] = []
+        frame_errors: list[str] = []
+        for frame_number, frame in enumerate(self._action_frames(text), start=1):
+            action, error = self._parse_action_frame(frame, frame_number)
+            if action is not None:
+                actions.append(action)
+                continue
+            if error:
+                frame_errors.append(error)
+        if not actions:
+            reason = "expected at least one valid action frame ending with " + self.ACTION_FRAME_END
+            if frame_errors:
+                reason += "; " + "; ".join(frame_errors[:3])
+            return self._invalid_model_response(content, reason)
+        response: Json = {"actions": actions}
+        if frame_errors:
+            response["_format_frame_errors"] = frame_errors
+        return response
+
+    def _action_frames(self, text: str) -> list[str]:
+        frames: list[str] = []
+        current: list[str] = []
+        for line in text.splitlines():
+            if not self._has_action_frame_end(line):
+                current.append(line)
+                continue
+            parts = self.ACTION_FRAME_END_SPLIT_PATTERN.split(line)
+            for index, part in enumerate(parts):
+                if part:
+                    current.append(part)
+                if index < len(parts) - 1:
+                    frames.append("\n".join(current).strip())
+                    current = []
+        trailing = "\n".join(current).strip()
+        if trailing:
+            frames.append(trailing)
+        return frames
+
+    def _completed_action_frames(self, text: str) -> tuple[list[str], str]:
+        frames: list[str] = []
+        current: list[str] = []
+        for line in text.splitlines(keepends=True):
+            if not self._has_action_frame_end(line):
+                current.append(line)
+                continue
+            parts = self.ACTION_FRAME_END_SPLIT_PATTERN.split(line)
+            for index, part in enumerate(parts):
+                if part:
+                    current.append(part)
+                if index < len(parts) - 1:
+                    frames.append("".join(current).strip())
+                    current = []
+        return frames, "".join(current)
+
+    def _parse_action_frame(self, frame: str, frame_number: int) -> tuple[Json | None, str]:
+        frame = frame.strip()
+        if not frame:
+            return None, ""
         try:
-            value = json.loads(text)
-        except json.JSONDecodeError:
-            return self._invalid_model_response(content)
+            value = json_repair.loads(frame)
+        except Exception as error:
+            return None, "frame " + str(frame_number) + ": " + str(error)
         if not isinstance(value, dict):
-            return self._invalid_model_response(content)
-        return value
+            return None, "frame " + str(frame_number) + ": expected JSON object action"
+        if not _json_str(value.get("type")):
+            return None, "frame " + str(frame_number) + ": action missing type"
+        return value, ""
+
+    def _has_action_frame_end(self, line: str) -> bool:
+        return self.ACTION_FRAME_END_SPLIT_PATTERN.search(line) is not None
+
+    def _is_action_frame_end(self, line: str) -> bool:
+        return self.ACTION_FRAME_END_PATTERN.match(line) is not None
 
     def _strip_json_fence(self, text: str) -> str:
         if not text.startswith("```"):
@@ -2179,18 +2346,19 @@ class ModelClient:
                 text = text[len("</think>") :].lstrip()
         return text
 
-    def _invalid_model_response(self, content: str) -> Json:
+    def _invalid_model_response(self, content: str, reason: str = "expected one JSON object matching the Output JSON schema") -> Json:
         guidance = ""
         if self._looks_like_native_tool_call(content):
             guidance = (
-                " Native tool_call syntax is not supported; return one JSON object with tool_calls entries like "
-                '{"name":"Read","intention":"...","args":["nanocode.py","0","100"]}.'
+                " Native tool_call syntax is not supported; return an action frame like "
+                '{"type":"tool","name":"Read","intention":"...","args":["nanocode.py","0","100"]}\n__END_ACTION__.'
             )
         return {
-            "goal_reached": False,
-            "tool_calls": None,
-            "message_to_user": None,
-            "_format_error": "Invalid model output: expected one JSON object matching the Output JSON schema. Return strict JSON only. Bad output: "
+            "actions": [],
+            "_format_bad_output": content,
+            "_format_error": "Invalid model output: "
+            + reason
+            + ". Return action frames only. Bad output: "
             + _shorten(content)
             + guidance,
         }
@@ -2471,6 +2639,9 @@ class AgentStateUpdater:
             before_verification,
         )
 
+    def _actions(self, response: Json) -> list[Json]:
+        return [action for action in (_json_dict(item) for item in _json_list(response.get("actions"))) if action]
+
     def apply_tool_call_summaries(self, response: Json) -> None:
         self._apply_tool_call_summaries(response)
 
@@ -2567,7 +2738,7 @@ class AgentStateUpdater:
         return text if len(text) <= limit else text[: limit - 3] + "..."
 
     def _apply_tool_call_summaries(self, response: Json) -> None:
-        summaries = _json_list(response.get("last_tool_calls_summaries"))
+        summaries = [action for action in self._actions(response) if _json_str(action.get("type")) == "tool_summary"]
         if not summaries:
             return
         pending = [event for event in self.tool_runner.latest_events if not event.summary]
@@ -2615,42 +2786,42 @@ class AgentStateUpdater:
         return [detail for detail in details if detail]
 
     def _apply_goal(self, response: Json) -> bool:
-        update = _json_str(response.get("goal_update"))
         changed = False
-        if update is not None:
-            changed = update != self.session.current.goal
-            self.session.current.goal = update
-        reached = response.get("goal_reached")
-        if isinstance(reached, bool):
-            self.session.current.goal_reached = reached
+        for action in self._actions(response):
+            action_type = _json_str(action.get("type"))
+            if action_type == "goal":
+                update = _json_str(action.get("text"))
+                if update is not None:
+                    changed = changed or update != self.session.current.goal
+                    self.session.current.goal = update
         return changed
 
     def _apply_plan(self, response: Json) -> bool:
-        update = _json_dict(response.get("plan_update"))
-        if not update:
-            return False
-        items = _json_list(update.get("items"))
-        if update.get("mode") == "replace":
-            self.session.current.plan = [item for item in (self._plan_item_from_json(raw) for raw in items) if item]
-            return True
-        for raw in items:
-            patch = _json_dict(raw)
-            op = _json_str(patch.get("op")) or "add"
-            item_id = _json_str(patch.get("id")) or ""
-            if op == "remove":
-                self.session.current.plan = [item for item in self.session.current.plan if item.id != item_id]
-                continue
-            plan_item = self._plan_item_from_json(patch)
-            if plan_item is None:
+        replaced = False
+        for update in [action for action in self._actions(response) if _json_str(action.get("type")) == "plan"]:
+            items = _json_list(update.get("items"))
+            if update.get("mode") == "replace":
+                self.session.current.plan = [item for item in (self._plan_item_from_json(raw) for raw in items) if item]
+                replaced = True
                 continue
-            existing = next((item for item in self.session.current.plan if item.id == plan_item.id and item.id), None)
-            if existing:
-                existing.text = plan_item.text
-                existing.status = plan_item.status
-                existing.evidence = plan_item.evidence
-            else:
-                self.session.current.plan.append(plan_item)
-        return False
+            for raw in items:
+                patch = _json_dict(raw)
+                op = _json_str(patch.get("op")) or "add"
+                item_id = _json_str(patch.get("id")) or ""
+                if op == "remove":
+                    self.session.current.plan = [item for item in self.session.current.plan if item.id != item_id]
+                    continue
+                plan_item = self._plan_item_from_json(patch)
+                if plan_item is None:
+                    continue
+                existing = next((item for item in self.session.current.plan if item.id == plan_item.id and item.id), None)
+                if existing:
+                    existing.text = plan_item.text
+                    existing.status = plan_item.status
+                    existing.evidence = plan_item.evidence
+                else:
+                    self.session.current.plan.append(plan_item)
+        return replaced
 
     def _plan_item_from_json(self, value: JsonValue) -> PlanItem | None:
         item = _json_dict(value)
@@ -2668,58 +2839,55 @@ class AgentStateUpdater:
         )
 
     def _apply_known(self, response: Json) -> None:
-        for raw in _json_list(response.get("known_append")):
-            item = _json_dict(raw)
-            fact = _json_str(item.get("fact")) if item else _json_str(raw)
-            if not fact:
-                continue
-            details = [_json_str(detail) or "" for detail in _json_list(item.get("details") if item else None)]
-            details = [detail for detail in details if detail]
-            if not any(known.fact == fact for known in self.session.current.known):
-                self.session.current.known.append(KnownItem(fact=fact, details=details))
+        for action in [action for action in self._actions(response) if _json_str(action.get("type")) == "known"]:
+            for raw in _json_list(action.get("items")):
+                item = _json_dict(raw)
+                fact = _json_str(item.get("fact")) if item else _json_str(raw)
+                if not fact:
+                    continue
+                details = [_json_str(detail) or "" for detail in _json_list(item.get("details") if item else None)]
+                details = [detail for detail in details if detail]
+                if not any(known.fact == fact for known in self.session.current.known):
+                    self.session.current.known.append(KnownItem(fact=fact, details=details))
 
     def _apply_current_context(self, response: Json) -> None:
-        update = _json_dict(response.get("current_context_update"))
-        if not update:
-            return
-        if update.get("mode") == "replace":
-            self.session.current.current_context = []
-        for raw in _json_list(update.get("items")):
-            item = _json_dict(raw)
-            note = _json_str(item.get("note")) if item else _json_str(raw)
-            if not note:
-                continue
-            details = [_json_str(detail) or "" for detail in _json_list(item.get("details") if item else None)]
-            details = [detail for detail in details if detail]
-            existing = next((context for context in self.session.current.current_context if context.note == note), None)
-            if existing:
-                existing.details = details
-            else:
-                self.session.current.current_context.append(CurrentContextItem(note=note, details=details))
+        for update in [action for action in self._actions(response) if _json_str(action.get("type")) == "context"]:
+            if update.get("mode") == "replace":
+                self.session.current.current_context = []
+            for raw in _json_list(update.get("items")):
+                item = _json_dict(raw)
+                note = _json_str(item.get("note")) if item else _json_str(raw)
+                if not note:
+                    continue
+                details = [_json_str(detail) or "" for detail in _json_list(item.get("details") if item else None)]
+                details = [detail for detail in details if detail]
+                existing = next((context for context in self.session.current.current_context if context.note == note), None)
+                if existing:
+                    existing.details = details
+                else:
+                    self.session.current.current_context.append(CurrentContextItem(note=note, details=details))
         if len(self.session.current.current_context) > self.CURRENT_CONTEXT_LIMIT:
             self.session.current.current_context = self.session.current.current_context[-self.CURRENT_CONTEXT_LIMIT :]
 
     def _apply_verification(self, response: Json) -> None:
-        data = _json_dict(response.get("verification"))
-        if not data:
-            return
-        method = _json_str(data.get("method"))
-        if method is not None:
-            if method != self.session.current.verification.method:
-                self.session.current.verification.evidence = ""
-            self.session.current.verification.method = method
-        status = _json_str(data.get("status"))
-        if status == "pending":
-            self.session.current.verification.status = VerificationStatus.REQUIRED
-            if "evidence" not in data:
-                self.session.current.verification.evidence = ""
-        elif status == "passed":
-            self.session.current.verification.status = VerificationStatus.DONE
-        elif status == "blocked":
-            self.session.current.verification.status = VerificationStatus.BLOCKED
-        evidence = _json_str(data.get("evidence"))
-        if evidence is not None:
-            self.session.current.verification.evidence = evidence
+        for data in [action for action in self._actions(response) if _json_str(action.get("type")) == "verify"]:
+            method = _json_str(data.get("method"))
+            if method is not None:
+                if method != self.session.current.verification.method:
+                    self.session.current.verification.evidence = ""
+                self.session.current.verification.method = method
+            status = _json_str(data.get("status"))
+            if status == "pending":
+                self.session.current.verification.status = VerificationStatus.REQUIRED
+                if "evidence" not in data:
+                    self.session.current.verification.evidence = ""
+            elif status == "passed":
+                self.session.current.verification.status = VerificationStatus.DONE
+            elif status == "blocked":
+                self.session.current.verification.status = VerificationStatus.BLOCKED
+            evidence = _json_str(data.get("evidence"))
+            if evidence is not None:
+                self.session.current.verification.evidence = evidence
 
     def _reset_stale_verification(self, response: Json, *, goal_changed: bool, plan_replaced: bool) -> None:
         verification = self.session.current.verification
@@ -2731,7 +2899,7 @@ class AgentStateUpdater:
             return
         if (
             plan_replaced
-            and not _json_dict(response.get("verification"))
+            and not any(_json_str(action.get("type")) == "verify" for action in self._actions(response))
             and verification.status
             in {
                 VerificationStatus.REQUIRED,
@@ -2822,7 +2990,9 @@ class Agent:
             self.latest_agent_feedback = ""
         return prompt
 
-    def request(self, system_prompt: str, user_prompt: str, *, activity: str = "main") -> Json:
+    def request(self, system_prompt: str, user_prompt: str, *, activity: str = "main", on_action: ActionCallback | None = None) -> Json:
+        if isinstance(self.model_client, ModelClient):
+            return self.model_client.request(system_prompt, user_prompt, activity=activity, on_action=on_action)
         return self.model_client.request(system_prompt, user_prompt, activity=activity)
 
     def compact_history(self) -> int:
@@ -2848,7 +3018,7 @@ class Agent:
         consecutive_format_errors = 0
 
         for _ in range(self.session.max_agent_steps):
-            response = self.step()
+            response = self.step(on_action=self._stream_action_preview_callback(on_message) if on_message is not None else None)
             format_error = _json_str(response.get("_format_error"))
             if format_error:
                 consecutive_format_errors += 1
@@ -2860,24 +3030,29 @@ class Agent:
                         "Format_Gate: stopped after "
                         + str(self.MAX_CONSECUTIVE_FORMAT_ERRORS)
                         + " consecutive invalid model outputs. "
-                        + _shorten(format_error, 180),
+                        + self._format_gate_debug_details(response, format_error),
                     )
                     raise LLMError(
                         "model returned invalid output " + str(self.MAX_CONSECUTIVE_FORMAT_ERRORS) + " times in a row: " + _shorten(format_error, 300)
                     )
                 self._report_gate(
                     on_message,
-                    "Retrying: model returned invalid output.",
-                    "Format_Gate: retrying model response. " + _shorten(format_error, 180),
+                    self._format_gate_user_message("Retrying: model returned invalid output", format_error),
+                    "Format_Gate: retrying model response. " + self._format_gate_debug_details(response, format_error),
                 )
                 continue
             consecutive_format_errors = 0
-            tool_calls = _json_list(response.get("tool_calls"))
+            actions = self._response_actions(response)
+            tool_calls = self._tool_calls_from_actions(actions)
+            messages = self._messages_from_actions(actions)
+            if self.session.debug and on_message is not None:
+                frame_error_report = self._format_frame_error_report(response)
+                if frame_error_report:
+                    on_message(frame_error_report)
             self.apply_response(response)
             if on_message is not None and self.state_updater.latest_report:
                 on_message(self.state_updater.latest_report)
-            message = _json_str(response.get("message_to_user"))
-            if message:
+            for message in messages:
                 self.session.append_conversation(AssistantMessage(content=message))
                 if on_message is not None:
                     on_message(message)
@@ -2889,8 +3064,6 @@ class Agent:
                         on_message(report)
                 self.maybe_auto_compact()
                 continue
-            if self.session.current.goal_reached and self.session.current.verification.status != VerificationStatus.REQUIRED:
-                return response
             if self.session.current.verification.status == VerificationStatus.REQUIRED:
                 self.session.current.goal_reached = False
                 self.latest_agent_feedback = self._format_verification_gate()
@@ -2900,7 +3073,10 @@ class Agent:
                     "Verification_Gate: retrying until verification is passed or blocked.",
                 )
                 continue
-            if not self.session.current.goal_reached:
+            if messages:
+                self.session.current.goal_reached = True
+                return response
+            if not messages:
                 self.latest_agent_feedback = self._format_continuation_hint()
                 self._report_gate(
                     on_message,
@@ -2915,6 +3091,22 @@ class Agent:
         if on_message is not None:
             on_message(debug_message if self.session.debug else message)
 
+    def _format_gate_user_message(self, prefix: str, format_error: str) -> str:
+        detail = format_error
+        for marker in (". Bad output:", " Bad output:"):
+            if marker in detail:
+                detail = detail.split(marker, 1)[0]
+                break
+        if detail.startswith("Invalid model output: "):
+            detail = detail[len("Invalid model output: ") :]
+        return prefix + ": " + _shorten(detail, 180)
+
+    def _format_gate_debug_details(self, response: Json, format_error: str) -> str:
+        bad_output = _json_str(response.get("_format_bad_output"))
+        if bad_output is None:
+            return _shorten(format_error, 180)
+        return _shorten(format_error, 180) + "\nFull bad output:\n" + bad_output
+
     def _compact_gate_report(self, gate: str) -> str:
         lines = gate.splitlines()
         headline = lines[0] if lines else "Gate"
@@ -2923,10 +3115,13 @@ class Agent:
             return headline + ": " + _shorten("; ".join(details[:3]), 220)
         return headline
 
-    def step(self) -> Json:
-        response = self.request(self.build_system_prompt(), self.build_user_prompt(consume_latest_tool_results=False), activity="main")
+    def step(self, *, on_action: ActionCallback | None = None) -> Json:
+        response = self.request(self.build_system_prompt(), self.build_user_prompt(consume_latest_tool_results=False), activity="main", on_action=on_action)
         if _json_str(response.get("_format_error")):
             return response
+        invalid_response = self._validate_action_response(response)
+        if invalid_response is not None:
+            return invalid_response
         self.latest_tool_call_results = ""
         self.latest_agent_feedback = ""
         self.state_updater.apply_tool_call_summaries(response)
@@ -2935,6 +3130,47 @@ class Agent:
     def apply_response(self, response: Json) -> None:
         self.state_updater.apply(response)
 
+    def _stream_action_preview_callback(self, on_message: MessageCallback | None) -> ActionCallback:
+        def preview(action: Json) -> None:
+            if on_message is None:
+                return
+            report = self._format_stream_action_preview(action)
+            if report:
+                on_message(report)
+
+        return preview
+
+    def _format_stream_action_preview(self, action: Json) -> str:
+        if _json_str(action.get("type")) != "tool":
+            return ""
+        try:
+            call = self.tool_runner.parse_tool_call(action)
+        except ToolCallError:
+            return ""
+        label = "Queued: " + self._format_stream_tool_label(call)
+        if call.intention:
+            label += " - " + _shorten(call.intention, 80)
+        return label
+
+    def _format_stream_tool_label(self, call: ParsedToolCall) -> str:
+        args = call.args
+        if call.name == "Bash":
+            return "Bash"
+        if call.name in {"Read", "ReplaceRange"} and args:
+            return self._format_stream_path_range_label(call.name, args)
+        if call.name == "Search":
+            path = args[1] if len(args) >= 2 and args[1] else ""
+            return "Search" + ((" " + _shorten(path, 48)) if path else "")
+        if args:
+            return call.name + " " + _shorten(args[0], 48)
+        return call.name
+
+    def _format_stream_path_range_label(self, name: str, args: list[str]) -> str:
+        label = name + " " + _shorten(args[0], 48)
+        if len(args) >= 3:
+            label += ":" + args[1] + "-" + args[2]
+        return label
+
     def execute_tool_calls(
         self,
         tool_calls: list[JsonValue],
@@ -2952,12 +3188,12 @@ class Agent:
             [
                 "Verification_Gate: required before completion.",
                 "Method: " + method,
-                'Next_Action: run a relevant verification tool call, or return verification.status="passed" or "blocked" with evidence if verification is already resolved.',
+                'Next_Action: run a relevant tool action, or return a verify action with status="passed" or "blocked" and evidence if verification is already resolved.',
             ]
         )
 
     def _format_continuation_hint(self) -> str:
-        return "No tool calls and goal not reached. Continue with the next useful action."
+        return "No tool actions and no message action. Continue with the next useful action."
 
     def _missing_tool_summaries(self) -> list[ToolCallEvent]:
         return [event for event in self.tool_runner.latest_events if not event.summary]
@@ -2986,7 +3222,7 @@ class Agent:
         for event in needs_read:
             lines.append("- Read(" + event.result_file + ") before continuing")
         lines.append(
-            "Next_Action: return last_tool_calls_summaries for missing results, read result_file only when it is the cheapest accurate fallback, or continue with source tools such as Search/ListDir."
+            "Next_Action: return tool_summary actions for missing results, read result_file with a tool action only when it is the cheapest accurate fallback, or continue with source tools such as Search/ListDir."
         )
         return "\n".join(lines)
 
@@ -3003,6 +3239,39 @@ class Agent:
                 return True
         return False
 
+    def _invalid_action_response(self, response: Json, reason: str) -> Json:
+        return {
+            "actions": [],
+            "_format_error": "Invalid model output: "
+            + reason
+            + ". Return action frames only. Bad output: "
+            + _shorten(json.dumps(response, ensure_ascii=False)),
+        }
+
+    def _validate_action_response(self, response: Json) -> Json | None:
+        if not isinstance(response.get("actions"), list):
+            return self._invalid_action_response(response, "expected actions array")
+        extra_keys = sorted(str(key) for key in response.keys() if key != "actions" and not str(key).startswith("_format_"))
+        if extra_keys:
+            return self._invalid_action_response(response, "unexpected top-level keys: " + ", ".join(extra_keys))
+        return None
+
+    def _format_frame_error_report(self, response: Json) -> str:
+        errors = [_json_str(error) or "" for error in _json_list(response.get("_format_frame_errors"))]
+        errors = [error for error in errors if error]
+        if not errors:
+            return ""
+        return "Format_Warning: ignored invalid action frame(s).\n" + "\n".join("- " + _shorten(error, 220) for error in errors)
+
+    def _response_actions(self, response: Json) -> list[Json]:
+        return [action for action in (_json_dict(item) for item in _json_list(response.get("actions"))) if action]
+
+    def _tool_calls_from_actions(self, actions: list[Json]) -> list[JsonValue]:
+        return [action for action in actions if _json_str(action.get("type")) == "tool"]
+
+    def _messages_from_actions(self, actions: list[Json]) -> list[str]:
+        return [message for message in (_json_str(action.get("text")) for action in actions if _json_str(action.get("type")) == "message") if message]
+
 
 ############################
 # Commands
@@ -3042,6 +3311,7 @@ COMMANDS: tuple[CommandSpec, ...] = (
     CommandSpec("/compact-at", "Show or set auto-compact threshold", "Config", "/compact-at [number]"),
     CommandSpec("/reason", "Show or toggle reasoning", "Config", "/reason [on|off|status]"),
     CommandSpec("/reason_effort", "Show or set reasoning effort", "Config", "/reason_effort [minimal|low|medium|high|xhigh]"),
+    CommandSpec("/stream", "Show or toggle streaming responses", "Config", "/stream [on|off|status]"),
     CommandSpec("/yolo", "Show or toggle confirmation bypass", "Config", "/yolo [on|off|status]"),
     CommandSpec("/exit", "Exit nanocode", "Control", "/exit"),
     CommandSpec("/quit", "Exit nanocode", "Control", "/quit"),
@@ -3071,6 +3341,7 @@ class CommandDispatcher:
             "/compact-at": self._compact_at,
             "/reason": self._reason,
             "/reason_effort": self._reason_effort,
+            "/stream": self._stream,
             "/yolo": self._yolo,
             "/blackboard": self._blackboard,
         }
@@ -3129,11 +3400,13 @@ class CommandDispatcher:
             return "Usage: /status"
         session = self.agent.session
         reasoning = session.reasoning_effort if session.reasoning else "off"
+        stream = "on" if session.stream else "off"
         yolo = "on" if session.yolo else "off"
         return "\n".join(
             [
                 "model: " + (session.model or "(empty)"),
                 "reasoning: " + reasoning,
+                "stream: " + stream,
                 "yolo: " + yolo,
                 "conversation: " + str(len(session.conversation)) + "/" + str(session.compact_at),
                 "tokens: last=" + _format_count(session.last_total_tokens) + " session=" + _format_count(session.session_total_tokens),
@@ -3198,6 +3471,17 @@ class CommandDispatcher:
         self.agent.session.reasoning_effort = args
         return "Reasoning effort set to: " + args
 
+    def _stream(self, args: str) -> str:
+        if args == "on":
+            self.agent.session.stream = True
+            return "Streaming enabled"
+        if args == "off":
+            self.agent.session.stream = False
+            return "Streaming disabled"
+        if args in {"", "status"}:
+            return "Streaming is " + ("on" if self.agent.session.stream else "off")
+        return "Usage: /stream [on|off|status]"
+
     def _yolo(self, args: str) -> str:
         if args == "on":
             self.agent.session.yolo = True
@@ -3558,6 +3842,9 @@ class AgentLoop:
         if message.startswith("Tool Calls"):
             self._emit_segments(self._tool_segments(message), message)
             return
+        if message.startswith("Queued:"):
+            self._emit_segments(self._queued_segments(message), message)
+            return
         if message.startswith("Error:"):
             self._emit_segments([("bold ansired", message + "\n")], message)
             return
@@ -3661,6 +3948,15 @@ class AgentLoop:
                 segments.extend([("ansibrightblack", line + "\n")])
         return segments
 
+    def _queued_segments(self, message: str) -> list[tuple[str, str]]:
+        body = message[len("Queued:") :].strip()
+        target, separator, reason = body.partition(" - ")
+        segments: list[tuple[str, str]] = [("ansibrightblack", "Queued: "), ("ansicyan", target)]
+        if separator:
+            segments.extend([("ansibrightblack", " - "), ("ansimagenta", reason)])
+        segments.append(("", "\n"))
+        return segments
+
     def _verify_style(self, badge: str) -> str:
         if "required" in badge:
             return "bold ansimagenta"

{nanocode_cli-0.2.7 → nanocode_cli-0.2.8/nanocode_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.2.7
+Version: 0.2.8
 Summary: A lightweight terminal-based AI coding assistant
 Author-email: hit9 <hit9@icloud.com>
 License-Expression: BSD-3-Clause
@@ -21,6 +21,7 @@ Classifier: Topic :: Terminals
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: json-repair>=0.39
 Requires-Dist: prompt-toolkit>=3.0
 Requires-Dist: typing-extensions>=4.7
 Provides-Extra: dev
@@ -76,6 +77,7 @@ export NANOCODE_DIR=".nanocode"
 export NANOCODE_TEMPERATURE="0.7"
 export NANOCODE_REASONING="on"
 export NANOCODE_REASONING_EFFORT="medium"
+export NANOCODE_STREAM="on"
 export NANOCODE_MODEL_TIMEOUT="60"
 export NANOCODE_SHELL_TIMEOUT="60"
 export NANOCODE_COMPACT_AT="100"

{nanocode_cli-0.2.7 → nanocode_cli-0.2.8}/nanocode_cli.egg-info/requires.txt

@@ -1,3 +1,4 @@
+json-repair>=0.39
 prompt-toolkit>=3.0
 typing-extensions>=4.7
 

{nanocode_cli-0.2.7 → nanocode_cli-0.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nanocode-cli"
-version = "0.2.7"
+version = "0.2.8"
 description = "A lightweight terminal-based AI coding assistant"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -27,6 +27,7 @@ classifiers = [
     "Topic :: Terminals",
 ]
 dependencies = [
+    "json-repair>=0.39",
     "prompt-toolkit>=3.0",
     "typing-extensions>=4.7",
 ]