nanocode-cli 0.3.26__tar.gz → 0.3.28__tar.gz

{nanocode_cli-0.3.26/nanocode_cli.egg-info → nanocode_cli-0.3.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.3.26
+Version: 0.3.28
 Summary: A lightweight terminal-based AI coding assistant
 Author-email: hit9 <hit9@icloud.com>
 License-Expression: BSD-3-Clause

{nanocode_cli-0.3.26 → nanocode_cli-0.3.28}/nanocode.py

@@ -51,7 +51,8 @@ from prompt_toolkit.output.defaults import create_output
 from prompt_toolkit.patch_stdout import patch_stdout
 from prompt_toolkit.styles import Style
 
-__version__ = "0.3.26"
+__version__ = "0.3.28"
+HTTP_USER_AGENT = "nanocode/" + __version__
 
 
 JsonValue: TypeAlias = Any
@@ -820,6 +821,10 @@ class RuntimeState:
     current_model_call_started_at: float = 0.0
     current_model_call_label: str = ""
     current_model_call_reasoning_label: str = ""
+    current_model_call_activity: str = ""
+    current_model_call_has_content: bool = False
+    status_notice: str = ""
+    status_notice_until: float = 0.0
     conversation: list[ConversationItem] = field(default_factory=list)
     user_rules: UserRules = field(default_factory=UserRules)
     range_fingerprints: RangeFingerprintStore = field(default_factory=RangeFingerprintStore)
@@ -3382,9 +3387,10 @@ class ModelClient:
 
     def __init__(self, session: Session):
         self.session = session
+        self._timeout_reason = "request model timeout"
 
     def _timeout_handler(self, signum: int, frame: Any) -> None:
-        raise ModelRequestTimeout()
+        raise ModelRequestTimeout(self._timeout_reason)
 
     def request(
         self,
@@ -3431,15 +3437,19 @@ class ModelClient:
             headers={
                 "Authorization": "Bearer " + config.key,
                 "Content-Type": "application/json",
+                "User-Agent": HTTP_USER_AGENT,
             },
         )
         try:
             self.session.state.current_model_call_started_at = time.monotonic()
             self.session.state.current_model_call_label = model
             self.session.state.current_model_call_reasoning_label = config.reasoning_effort if config.reasoning else "off"
+            self.session.state.current_model_call_activity = activity
+            self.session.state.current_model_call_has_content = False
             request_deadline = self.session.state.current_model_call_started_at + max(0, timeout)
             previous_handler = signal.getsignal(signal.SIGALRM)
             signal.signal(signal.SIGALRM, self._timeout_handler)
+            self._timeout_reason = "request model timeout"
             signal.setitimer(signal.ITIMER_REAL, max(0, timeout))
             try:
                 with urllib.request.urlopen(request, timeout=timeout) as response:
@@ -3458,8 +3468,10 @@ class ModelClient:
                 self.session.state.current_model_call_started_at = 0.0
                 self.session.state.current_model_call_label = ""
                 self.session.state.current_model_call_reasoning_label = ""
-        except ModelRequestTimeout:
-            raise LLMError("request model timeout")
+                self.session.state.current_model_call_activity = ""
+                self.session.state.current_model_call_has_content = False
+        except ModelRequestTimeout as error:
+            raise LLMError(str(error) or "request model timeout")
         except (socket.timeout, TimeoutError):
             raise LLMError("request model timeout")
         except urllib.error.HTTPError as error:
@@ -3523,6 +3535,7 @@ class ModelClient:
                 continue
             if not first_content_seen:
                 first_content_seen = True
+                self.session.state.current_model_call_has_content = True
                 self._arm_stream_timeout(request_deadline=request_deadline, first_content_seen=True, first_token_timeout=first_token_timeout)
             parts.append(content)
         return "".join(parts), usage
@@ -3530,9 +3543,12 @@ class ModelClient:
     def _arm_stream_timeout(self, *, request_deadline: float, first_content_seen: bool, first_token_timeout: int | None) -> None:
         remaining = request_deadline - time.monotonic()
         if remaining <= 0:
-            raise ModelRequestTimeout()
+            raise ModelRequestTimeout("request model timeout")
+        self._timeout_reason = "request model timeout"
         if not first_content_seen and first_token_timeout is not None and first_token_timeout > 0:
-            remaining = min(remaining, first_token_timeout)
+            if first_token_timeout < remaining:
+                remaining = first_token_timeout
+                self._timeout_reason = "request first token timeout"
         signal.setitimer(signal.ITIMER_REAL, remaining)
 
     def _write_debug_prompt(self, *, activity: str, messages: list[Json]) -> str:
@@ -3642,6 +3658,7 @@ class ModelClient:
         if isinstance(value, dict):
             if "actions" in value:
                 return self._actions_from_json_value(value.get("actions"))
+            self._normalize_tool_type(value)
             if not _json_str(value.get("type")):
                 return [], "action missing type"
             return [value], ""
@@ -3651,12 +3668,19 @@ class ModelClient:
                 action = _json_dict(raw)
                 if not action:
                     return [], "array item " + str(index) + ": expected JSON object action"
+                self._normalize_tool_type(action)
                 if not _json_str(action.get("type")):
                     return [], "array item " + str(index) + ": action missing type"
                 actions.append(action)
             return actions, ""
         return [], "expected JSON object action"
 
+    def _normalize_tool_type(self, action: Json) -> None:
+        action_type = _json_str(action.get("type"))
+        if action_type in TOOL_REGISTRY:
+            action["type"] = "tool"
+            action.setdefault("name", action_type)
+
     def _parse_unmarked_actions(self, text: str) -> tuple[list[Json], str]:
         actions: list[Json] = []
         decoder = json.JSONDecoder()
@@ -3667,8 +3691,8 @@ class ModelClient:
         if index < len(text) and text[index] != "{":
             if text[index] == "[":
                 try:
-                    value, index = decoder.raw_decode(text, index)
-                except json.JSONDecodeError as error:
+                    value, index = self._decode_json_array_text(text, index)
+                except (json.JSONDecodeError, ValueError) as error:
                     return [], str(error)
                 parsed, error = self._actions_from_json_value(value)
                 if error:
@@ -3706,6 +3730,28 @@ class ModelClient:
                 index += 1
             if index < len(text) and text[index] == ",":
                 index += 1
+                continue
+            if index < len(text) and text[index] != "{":
+                next_action = text.find("{", index)
+                if next_action < 0:
+                    return [], "unexpected text after JSON action"
+                progress = _shorten(" ".join(text[index:next_action].split()), 500)
+                if progress:
+                    actions.append({"type": "progress", "text": progress})
+                index = next_action
+
+    def _decode_json_array_text(self, text: str, index: int) -> tuple[JsonValue, int]:
+        decoder = json.JSONDecoder()
+        value, end = decoder.raw_decode(text, index)
+        cursor = end
+        while cursor < len(text) and text[cursor].isspace():
+            cursor += 1
+        if cursor >= len(text):
+            return value, cursor
+        value = json_repair.loads(text[index:])
+        if not isinstance(value, list):
+            raise ValueError("expected JSON action array")
+        return value, len(text)
 
     def _has_action_frame_end(self, line: str) -> bool:
         return self.ACTION_FRAME_END_SPLIT_PATTERN.search(line) is not None
@@ -4791,12 +4837,14 @@ class Agent:
                 self.session.state.turn_model_calls += 1
                 return self.model_client.request(system_prompt, user_prompt, activity=activity)
             except LLMError as error:
-                if str(error) != "request model timeout" or attempt >= len(self.MODEL_TIMEOUT_RETRY_DELAYS):
+                timeout_reason = str(error)
+                if timeout_reason not in ("request model timeout", "request first token timeout") or attempt >= len(self.MODEL_TIMEOUT_RETRY_DELAYS):
                     raise
                 delay = self.MODEL_TIMEOUT_RETRY_DELAYS[attempt]
+                self._set_status_notice("err:first_token" if timeout_reason == "request first token timeout" else "err:timeout")
                 if on_message is not None and self.session.settings.debug:
                     on_message(
-                        "Retrying: request model timeout; retry "
+                        "Retrying: " + timeout_reason + "; retry "
                         + str(attempt + 1)
                         + "/"
                         + str(len(self.MODEL_TIMEOUT_RETRY_DELAYS))
@@ -4807,6 +4855,10 @@ class Agent:
                 time.sleep(delay)
         raise LLMError("request model timeout")
 
+    def _set_status_notice(self, text: str, ttl: float = 5.0) -> None:
+        self.session.state.status_notice = text
+        self.session.state.status_notice_until = time.monotonic() + ttl
+
     def compact_history(self) -> int:
         return self.compactor.compact()
 
@@ -4832,6 +4884,7 @@ class Agent:
                 format_error = _json_str(response.get("_format_error"))
                 if format_error:
                     consecutive_format_errors += 1
+                    self._set_status_notice("err:format")
                     remember_error = self._remember_observe_error if self.mode == AgentMode.OBSERVE else self._remember_agent_error
                     remember_error(
                         self._format_gate_user_message("Error: model returned invalid output", format_error) + " Rule: return valid JSON action frames only."
@@ -4917,6 +4970,8 @@ class Agent:
     def _report_gate(self, on_message: MessageCallback | None, message: str, debug_message: str) -> None:
         if on_message is None:
             return
+        if message.startswith(("Retrying:", "Continuing:")) and self.session.state.status_notice_until <= time.monotonic():
+            self._set_status_notice("err:gate")
         if self.session.settings.debug:
             on_message(debug_message)
             return
@@ -4943,13 +4998,15 @@ class Agent:
         if self.mode == AgentMode.OBSERVE:
             system_prompt = self.prompt_builder.system_prompt(AGENT_OBSERVE_SYSTEM_PROMPT, tools=())
             user_prompt = self.build_observe_prompt()
+            activity = "observe"
         else:
             system_prompt = self.prompt_builder.system_prompt(
                 AGENT_PLAN_SYSTEM_PROMPT if self.session.settings.plan_mode else None,
                 tools=PLAN_MODE_TOOLS if self.session.settings.plan_mode else None,
             )
             user_prompt = self.build_user_prompt()
-        response = self.request(system_prompt, user_prompt, activity="agent", on_message=on_message)
+            activity = "agent"
+        response = self.request(system_prompt, user_prompt, activity=activity, on_message=on_message)
         if _json_str(response.get("_format_error")):
             return response
         invalid_response = self._validate_action_response(response)
@@ -5295,29 +5352,6 @@ class Agent:
         conflict = sorted((forgotten & protected) - released)
         return "active hypothesis source: " + ", ".join(conflict) if conflict else ""
 
-    def _plan_shape_error(self, actions: list[Json]) -> str:
-        plan = [PlanItem(text=item.text, status=item.status, id=item.id, context=item.context) for item in self.blackboard.plan]
-        changed = False
-        for action in actions:
-            action_type = _json_str(action.get("type"))
-            if action_type == "start":
-                items = self._plan_items_from_json(action.get("plan"))
-                if items:
-                    plan = items
-                    changed = True
-            elif action_type == "plan":
-                items = self._plan_items_from_json(action.get("items"))
-                if action.get("mode") != "patch":
-                    if items:
-                        plan = items
-                        changed = True
-                    continue
-                changed = self.state_updater._apply_plan_patches(plan, action.get("items")) or changed
-        doing = [item for item in plan if item.status == PlanStatus.DOING]
-        if changed and len(doing) > 1:
-            return "multiple doing plan items: " + self._format_plan_gate_items(doing)
-        return ""
-
     def _plan_items_from_json(self, value: JsonValue) -> list[PlanItem]:
         return [item for item in (self.state_updater._plan_item_from_json(raw) for raw in _json_list(value)) if item]
 
@@ -5425,15 +5459,6 @@ class Agent:
                 "ToolResult_Gate: " + forget_hypothesis_error + ".",
             )
             return True
-        plan_shape_error = self._plan_shape_error(ctx.actions)
-        if plan_shape_error:
-            self._remember_agent_error("Error: Plan is invalid: " + plan_shape_error + ". Rule: at most one Plan item may be doing.")
-            self._report_gate(
-                on_message,
-                "Retrying: keep only one plan item doing.",
-                "Plan_Gate: " + plan_shape_error + ".",
-            )
-            return True
         repeated_tool_retry_error = self._repeated_tool_retry_error(ctx.tool_calls)
         if repeated_tool_retry_error:
             self._remember_agent_error(
@@ -5730,15 +5755,6 @@ class Agent:
                 "ToolResult_Gate: " + forget_hypothesis_error + ".",
             )
             return AgentRunResult()
-        plan_shape_error = self._plan_shape_error(ctx.actions)
-        if plan_shape_error:
-            self._remember_observe_error("Error: Plan is invalid: " + plan_shape_error + ". Rule: at most one Plan item may be doing.")
-            self._report_gate(
-                on_message,
-                "Retrying: keep only one plan item doing.",
-                "Plan_Gate: " + plan_shape_error + ".",
-            )
-            return AgentRunResult()
         if any(_json_str(action.get("type")) == "verify" and _json_str(action.get("status")) == "pending" for action in ctx.actions):
             self._remember_observe_error("Error: cannot request new verification before observing latest results. Rule: keep or forget latest results first.")
             self._report_gate(
@@ -6239,7 +6255,7 @@ class CommandDispatcher:
             base_url = base_url[: -len("/chat/completions")]
         request = urllib.request.Request(
             base_url + "/models",
-            headers={"Authorization": "Bearer " + provider.key},
+            headers={"Authorization": "Bearer " + provider.key, "User-Agent": HTTP_USER_AGENT},
         )
         try:
             with urllib.request.urlopen(request, timeout=3) as response:
@@ -6645,9 +6661,24 @@ class StatusBar:
         if show_elapsed:
             parts.append(f"{turn_elapsed:.1f}s")
         if session.state.current_model_call_started_at > 0:
-            parts.append("calling(" + str(session.state.turn_model_calls) + "):" + f"{max(0.0, now - session.state.current_model_call_started_at):.1f}s")
+            activity = self._activity_label(session.state.current_model_call_activity)
+            if session.state.current_model_call_has_content:
+                activity += "*"
+            parts.append(
+                activity
+                + "("
+                + str(session.state.turn_model_calls)
+                + "):"
+                + f"{max(0.0, now - session.state.current_model_call_started_at):.1f}s"
+            )
+        if session.state.status_notice and session.state.status_notice_until > now:
+            parts.append(session.state.status_notice)
         return " | ".join(parts)
 
+    @staticmethod
+    def _activity_label(activity: str) -> str:
+        return {"compact": "compacting", "observe": "observing"}.get(activity, "working")
+
     def _sweep_fragments(self, text: str, now: float) -> list[tuple[str, str]]:
         if not text:
             return [("", "")]

{nanocode_cli-0.3.26 → nanocode_cli-0.3.28/nanocode_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.3.26
+Version: 0.3.28
 Summary: A lightweight terminal-based AI coding assistant
 Author-email: hit9 <hit9@icloud.com>
 License-Expression: BSD-3-Clause

{nanocode_cli-0.3.26 → nanocode_cli-0.3.28}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nanocode-cli"
-version = "0.3.26"
+version = "0.3.28"
 description = "A lightweight terminal-based AI coding assistant"
 readme = "README.md"
 requires-python = ">=3.11"