henosis-cli 0.6.6__py3-none-any.whl → 0.6.8__py3-none-any.whl

cli.py

@@ -683,7 +683,7 @@ class UI:
             for n, ty, sz in rows:
                 print(f"{n:<40} {ty:<8} {sz}")
 
-class ChatCLI:
+class ChatCLI:
     def __init__(
         self,
         server: str,
@@ -997,8 +997,10 @@ class ChatCLI:
         }
         # Track last used model for display
         self._last_used_model: Optional[str] = None
-        # Provider-native history for Kimi (preserve reasoning_content across turns)
-        self._kimi_raw_history: List[Dict[str, Any]] = []
+        # Provider-native history for Kimi (preserve reasoning_content across turns)
+        self._kimi_raw_history: List[Dict[str, Any]] = []
+        # Provider-native history for Gemini (preserve thoughtSignatures + strict tool-call chains across turns)
+        self._gemini_raw_history: List[Dict[str, Any]] = []
         # Last server billing info from /api/usage/commit
         self._last_commit_cost_usd: float = 0.0
         self._last_remaining_credits: Optional[float] = None
@@ -1955,14 +1957,15 @@ class ChatCLI:
             pass
         return data
 
-    def _apply_settings_dict(self, data: Dict[str, Any]) -> None:
-        try:
+    def _apply_settings_dict(self, data: Dict[str, Any]) -> None:
+        try:
+            old_system_prompt = getattr(self, "system_prompt", None)
             self.model = data.get("model", self.model)
             if "save_chat_history" in data:
                 try:
                     self.save_chat_history = bool(data.get("save_chat_history"))
                 except Exception:
-                    pass
+                    pass
             self.requested_tools = data.get("requested_tools", self.requested_tools)
             self.fs_scope = data.get("fs_scope", self.fs_scope)
             self.host_base = data.get("host_base", self.host_base)
@@ -2101,18 +2104,30 @@ class ChatCLI:
                     self.anthropic_cache_ttl = None
             except Exception:
                 pass
-            # Rebuild history if system prompt changed
-            self.history = []
-            if self.system_prompt:
-                self.history.append({"role": "system", "content": self.system_prompt})
-            # On settings load, do not assume the custom first-turn was injected yet
-            try:
-                self._did_inject_custom_first_turn = False
-            except Exception:
-                pass
-            self._apply_model_side_effects()
-        except Exception as e:
-            self.ui.warn(f"Failed to apply settings: {e}")
+            # Rebuild history if system prompt changed
+            try:
+                system_prompt_changed = old_system_prompt != getattr(self, "system_prompt", None)
+            except Exception:
+                system_prompt_changed = False
+
+            if system_prompt_changed:
+                # Changing the system prompt can materially alter the behavior of the assistant;
+                # warn the user and reset the current conversation history to avoid mixing contexts.
+                try:
+                    self.ui.warn("[settings] System prompt changed - clearing current conversation history.")
+                except Exception:
+                    pass
+                self.history = []
+                if self.system_prompt:
+                    self.history.append({"role": "system", "content": self.system_prompt})
+            # On settings load, do not assume the custom first-turn was injected yet
+            try:
+                self._did_inject_custom_first_turn = False
+            except Exception:
+                pass
+            self._apply_model_side_effects()
+        except Exception as e:
+            self.ui.warn(f"Failed to apply settings: {e}")
 
     async def _fetch_server_settings(self) -> Optional[Dict[str, Any]]:
         try:
@@ -3256,7 +3271,7 @@ class ChatCLI:
             "Fonts: San Serif, Inter, Geist, Mona Sans, IBM Plex Sans, Manrope\n"
         )
 
-    def _build_kimi_raw_messages(self, user_input: str) -> List[Dict[str, Any]]:
+    def _build_kimi_raw_messages(self, user_input: str) -> List[Dict[str, Any]]:
         """Build provider-native messages for Kimi preserving prior assistant reasoning_content.
         Includes prior provider-native turns and the current user message with first-turn injections.
         """
@@ -3274,8 +3289,31 @@ class ChatCLI:
         for m in (self._kimi_raw_history or []):
             raw.append(m)
         # Append current user message
-        raw.append({"role": "user", "content": content})
-        return raw
+        raw.append({"role": "user", "content": content})
+        return raw
+
+    def _normalize_gemini_raw_messages(self, rpm: Any) -> List[Dict[str, Any]]:
+        """Normalize Gemini provider-native history.
+
+        Ensures we only send a flat list of dicts back to the server.
+        This prevents accidental nesting like [[{...}, {...}]] which the
+        google-genai SDK rejects with pydantic union validation errors.
+        """
+        out: List[Dict[str, Any]] = []
+        if not isinstance(rpm, list):
+            return out
+        for item in rpm:
+            if item is None:
+                continue
+            if isinstance(item, list):
+                # Flatten one level
+                for sub in item:
+                    if isinstance(sub, dict):
+                        out.append(dict(sub))
+                continue
+            if isinstance(item, dict):
+                out.append(dict(item))
+        return out
 
     def _build_working_memory_injection(self) -> Optional[str]:
         try:
@@ -4603,7 +4641,7 @@ class ChatCLI:
             self.ui.success(f"Thread title set to: {self.thread_name}")
             return True
 
-        if cmd == "/clear":
+        if cmd == "/clear":
             self.history = [{"role": "system", "content": self.system_prompt}] if self.system_prompt else []
             self._did_inject_codebase_map = False
             try:
@@ -4615,9 +4653,10 @@ class ChatCLI:
                 self.messages_for_save = []
                 if not self.save_chat_history:
                     self.thread_uid = None
-                self._kimi_raw_history = []
-            except Exception:
-                pass
+                self._kimi_raw_history = []
+                self._gemini_raw_history = []
+            except Exception:
+                pass
             # Reset local cumulative token counters on session clear
             self._cum_input_tokens = 0
             self._cum_output_tokens = 0
@@ -5227,20 +5266,21 @@ class ChatCLI:
             self.save_settings()
             return True
 
-        if choice == "clear_history":
+        if choice == "clear_history":
             self.history = [{"role": "system", "content": self.system_prompt}] if self.system_prompt else []
             self._did_inject_codebase_map = False
             try:
                 self._did_inject_custom_first_turn = False
             except Exception:
                 pass
-            try:
+            try:
                 self.messages_for_save = []
                 if not self.save_chat_history:
                     self.thread_uid = None
-                self._kimi_raw_history = []
-            except Exception:
-                pass
+                self._kimi_raw_history = []
+                self._gemini_raw_history = []
+            except Exception:
+                pass
             # Reset local cumulative token counters on session clear
             self._cum_input_tokens = 0
             self._cum_output_tokens = 0
@@ -5479,13 +5519,23 @@ class ChatCLI:
                     headers["X-Request-Timeout"] = str(int(req_timeout_hint))
                 except Exception:
                     pass
-                # If using a Kimi model, include provider-native messages to preserve reasoning_content
-                try:
-                    if isinstance(self.model, str) and self.model.startswith("kimi-"):
-                        req_payload = dict(req_payload)
-                        req_payload["raw_provider_messages"] = self._build_kimi_raw_messages(user_input)
-                except Exception:
-                    pass
+                # If using a Kimi model, include provider-native messages to preserve reasoning_content
+                try:
+                    if isinstance(self.model, str) and self.model.startswith("kimi-"):
+                        req_payload = dict(req_payload)
+                        req_payload["raw_provider_messages"] = self._build_kimi_raw_messages(user_input)
+                except Exception:
+                    pass
+                # If using a Gemini model, include provider-native contents to preserve thought signatures
+                # and strict tool-call chains across HTTP turns.
+                try:
+                    if isinstance(self.model, str) and self.model.startswith("gemini-"):
+                        req_payload = dict(req_payload)
+                        hist = self._normalize_gemini_raw_messages(self._gemini_raw_history)
+                        if hist:
+                            req_payload["raw_provider_messages"] = hist
+                except Exception:
+                    pass
                 async with httpx.AsyncClient(timeout=http_timeout, cookies=self.cookies) as client:
                     async with client.stream("POST", self.stream_url, json=req_payload, headers=headers, follow_redirects=True) as resp:
                         if resp.status_code == 429:
@@ -6393,10 +6443,17 @@ class ChatCLI:
                                 except Exception as e:
                                     self.ui.warn(f"tools.callback error: {e}")
     
-                            elif event == "message.completed":
+                            elif event == "message.completed":
                                 # Safety: this block handles only 'message.completed'.
                                 usage = data.get("usage", {})
-                                model_used = data.get("model") or self.model
+                                model_used = data.get("model") or self.model
+                                # Gemini: server may include an authoritative provider-native history snapshot.
+                                try:
+                                    if isinstance(model_used, str) and model_used.startswith("gemini-"):
+                                        rpm = data.get("raw_provider_messages")
+                                        self._gemini_raw_history = self._normalize_gemini_raw_messages(rpm)
+                                except Exception:
+                                    pass
                                 # Mark completion for retry controller
                                 try:
                                     last_completed = True
@@ -7238,20 +7295,29 @@ class ChatCLI:
                                     pass
                                 return "".join(assistant_buf)
     
-                            elif event == "provider.message":
-                                # Provider-native message snapshot (e.g., Kimi assistant with reasoning_content)
-                                provider = (data.get("provider") or "").lower()
-                                msg = data.get("message")
-                                if bool(getattr(self, "retain_native_tool_results", False)) and provider == "kimi" and isinstance(msg, dict):
-                                    # Append as-is to local raw history for the next turn
-                                    try:
-                                        self._kimi_raw_history.append(dict(msg))
-                                    except Exception:
-                                        try:
-                                            self._kimi_raw_history.append(msg)  # type: ignore
-                                        except Exception:
-                                            pass
-                                continue
+                            elif event == "provider.message":
+                                # Provider-native message snapshot (e.g., Kimi assistant with reasoning_content)
+                                provider = (data.get("provider") or "").lower()
+                                msg = data.get("message")
+                                if provider == "gemini":
+                                    # Always retain Gemini provider-native messages (needed for multi-turn tool calling).
+                                    try:
+                                        if isinstance(msg, dict):
+                                            self._gemini_raw_history.append(dict(msg))
+                                        elif isinstance(msg, list):
+                                            self._gemini_raw_history.extend(self._normalize_gemini_raw_messages(msg))
+                                    except Exception:
+                                        pass
+                                if bool(getattr(self, "retain_native_tool_results", False)) and provider == "kimi" and isinstance(msg, dict):
+                                    # Append as-is to local raw history for the next turn
+                                    try:
+                                        self._kimi_raw_history.append(dict(msg))
+                                    except Exception:
+                                        try:
+                                            self._kimi_raw_history.append(msg)  # type: ignore
+                                        except Exception:
+                                            pass
+                                continue
     
                             else:
                                 # TEMP DEBUG: show unknown/unhandled events

{henosis_cli-0.6.6.dist-info → henosis_cli-0.6.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: henosis-cli
-Version: 0.6.6
+Version: 0.6.8
 Summary: henosis-cli — interactive CLI for the Henosis multi-provider streaming chat backend, with optional local tools.
 Author-email: henosis <henosis@henosis.us>
 License-Expression: LicenseRef-Proprietary

henosis_cli-0.6.8.dist-info/RECORD

@@ -0,0 +1,11 @@
+cli.py,sha256=Zfl9XOtxi2-OkVj_653t-gfKvxt0837OqeQek3B0fZ4,504826
+henosis_cli_tools/__init__.py,sha256=x3uaN_ub32uALx_oURna0VnuoSsj7i9NYY6uRsc2ZzM,1147
+henosis_cli_tools/cli_entry.py,sha256=OZTe_s9Hfy3mcsYG77T3RTdtCDod-CSwmhskbXjmmqs,1713
+henosis_cli_tools/input_engine.py,sha256=kGW6AgDGbdcVxlx5mvTPKYe4lYhho5wztvUAw7WlmTs,15286
+henosis_cli_tools/settings_ui.py,sha256=8rWsp0S3wT-dgkP0y20FOBmBBy7jYbDy8AuftmKcp4w,21368
+henosis_cli_tools/tool_impl.py,sha256=0iojZbVZhhPJybcmb2qYAuCesgQMp83JgPL2Py4PjT8,39250
+henosis_cli-0.6.8.dist-info/METADATA,sha256=yU7jKZvdNYRSowgJrk7hAAH32QLM3Xey4d8iVjrz2OA,5787
+henosis_cli-0.6.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+henosis_cli-0.6.8.dist-info/entry_points.txt,sha256=KmXDdmIjq1SVMs8FK3wHPA2i89RMaerzZHIetllMLIk,74
+henosis_cli-0.6.8.dist-info/top_level.txt,sha256=u7XMBcJ8Kb0n91WaSU-4Db8yURSUXFuOxGMsXti0a-g,34
+henosis_cli-0.6.8.dist-info/RECORD,,

henosis_cli_tools/tool_impl.py

@@ -70,12 +70,37 @@ _DEFAULT_ALLOWED_EXTS = {
     ".conf",
 }
 
-_MAX_FILE_BYTES = int(os.getenv("HENOSIS_MAX_FILE_BYTES", str(1_073_741_824)))
-_MAX_EDIT_BYTES = int(os.getenv("HENOSIS_MAX_EDIT_BYTES", str(1_073_741_824)))
-_EDIT_SAFEGUARD_MAX_LINES = int(os.getenv("HENOSIS_EDIT_SAFEGUARD_MAX_LINES", "3000"))
-_COMMAND_TIMEOUT_SEC = float(os.getenv("HENOSIS_COMMAND_TIMEOUT_SEC", "30"))
-# Max chars for stdout/stderr before truncation notice is applied
-_CMD_OUTPUT_MAX_CHARS = 3000
+_MAX_FILE_BYTES = int(os.getenv("HENOSIS_MAX_FILE_BYTES", str(1_073_741_824)))
+_MAX_EDIT_BYTES = int(os.getenv("HENOSIS_MAX_EDIT_BYTES", str(1_073_741_824)))
+_EDIT_SAFEGUARD_MAX_LINES = int(os.getenv("HENOSIS_EDIT_SAFEGUARD_MAX_LINES", "3000"))
+
+# Command timeout behavior:
+# - The tool call can request a per-invocation timeout via the `timeout` argument.
+# - The client/user may configure a DEFAULT (used when the tool omits timeout)
+#   and a MAX (hard cap for safety).
+# - Backward compatibility: legacy env var HENOSIS_COMMAND_TIMEOUT_SEC is treated as MAX.
+def _env_float(name: str, default: float) -> float:
+    try:
+        v = os.getenv(name, "")
+        if v is None:
+            return float(default)
+        s = str(v).strip()
+        if not s:
+            return float(default)
+        return float(s)
+    except Exception:
+        return float(default)
+
+
+_COMMAND_TIMEOUT_DEFAULT_SEC = _env_float("HENOSIS_COMMAND_TIMEOUT_DEFAULT_SEC", 360.0)
+_LEGACY_COMMAND_TIMEOUT_SEC_RAW = os.getenv("HENOSIS_COMMAND_TIMEOUT_SEC", "")
+if str(_LEGACY_COMMAND_TIMEOUT_SEC_RAW or "").strip():
+    _COMMAND_TIMEOUT_MAX_SEC = _env_float("HENOSIS_COMMAND_TIMEOUT_SEC", 900.0)
+else:
+    _COMMAND_TIMEOUT_MAX_SEC = _env_float("HENOSIS_COMMAND_TIMEOUT_MAX_SEC", 900.0)
+
+# Max chars for stdout/stderr before truncation notice is applied
+_CMD_OUTPUT_MAX_CHARS = 3000
 
 _VERBOSE_NOTICE = (
     "console output was EXTEREMELY verbose the ouput was truncated as to not overflow your context. here are the last 3k chars:\n"
@@ -322,13 +347,22 @@ def run_command(cmd: str, policy: FileToolPolicy, cwd: Optional[str] = None, tim
     base = os.path.basename(exe).lower()
     if (not allow_all) and (base not in allow_set):
         return {"ok": False, "error": f"command '{base}' not allowed"}
-    try:
-        requested = float(timeout) if timeout is not None else _COMMAND_TIMEOUT_SEC
-    except Exception:
-        requested = _COMMAND_TIMEOUT_SEC
-    timeout_s = min(max(0.01, requested), float(_COMMAND_TIMEOUT_SEC))
-    start = time.time()
-    try:
+    # Determine effective timeout: tool-controlled within a user-configurable maximum.
+    try:
+        requested = float(timeout) if timeout is not None else float(_COMMAND_TIMEOUT_DEFAULT_SEC)
+    except Exception:
+        requested = float(_COMMAND_TIMEOUT_DEFAULT_SEC)
+    try:
+        max_sec = float(_COMMAND_TIMEOUT_MAX_SEC)
+    except Exception:
+        max_sec = 900.0
+    if max_sec <= 0:
+        # Degenerate config; keep tool safe.
+        max_sec = 0.01
+    timeout_s = min(max(0.01, requested), max_sec)
+    timeout_was_clamped = bool(requested > max_sec)
+    start = time.time()
+    try:
         # Force UTF-8 decoding with replacement to avoid locale-dependent decode errors
         # on Windows (e.g., cp1252 UnicodeDecodeError in reader thread).
         proc = subprocess.run(
@@ -341,39 +375,51 @@ def run_command(cmd: str, policy: FileToolPolicy, cwd: Optional[str] = None, tim
             errors="replace",
             timeout=timeout_s,
         )
-        dur_ms = int((time.time() - start) * 1000)
+        dur_ms = int((time.time() - start) * 1000)
         # Truncate very verbose outputs to protect context size
         out = _truncate_if_verbose(proc.stdout)
         err = _truncate_if_verbose(proc.stderr)
-        return {
-            "ok": True,
-            "data": {
-                "cmd": cmd_str,
-                "cwd": str(cwd_path),
-                "exit_code": proc.returncode,
-                "stdout": out,
-                "stderr": err,
-                "timed_out": False,
-                "duration_ms": dur_ms,
-            },
-        }
-    except subprocess.TimeoutExpired as e:
-        dur_ms = int((time.time() - start) * 1000)
+        return {
+            "ok": True,
+            "data": {
+                "cmd": cmd_str,
+                "cwd": str(cwd_path),
+                "exit_code": proc.returncode,
+                "stdout": out,
+                "stderr": err,
+                "timed_out": False,
+                "duration_ms": dur_ms,
+                "timeout_requested_sec": requested,
+                "timeout_effective_sec": timeout_s,
+                "timeout_max_sec": max_sec,
+                "timeout_was_clamped": timeout_was_clamped,
+            },
+        }
+    except subprocess.TimeoutExpired as e:
+        dur_ms = int((time.time() - start) * 1000)
         # Even in timeout, ensure any captured output is truncated if overly verbose
         out = _truncate_if_verbose(e.stdout or "")
         err = _truncate_if_verbose(e.stderr or "")
-        return {
-            "ok": True,
-            "data": {
-                "cmd": cmd_str,
-                "cwd": str(cwd_path),
-                "exit_code": None,
-                "stdout": out,
-                "stderr": err,
-                "timed_out": True,
-                "duration_ms": dur_ms,
-            },
-        }
+        return {
+            "ok": True,
+            "data": {
+                "cmd": cmd_str,
+                "cwd": str(cwd_path),
+                "exit_code": None,
+                "stdout": out,
+                "stderr": err,
+                "timed_out": True,
+                "duration_ms": dur_ms,
+                "timeout_requested_sec": requested,
+                "timeout_effective_sec": timeout_s,
+                "timeout_max_sec": max_sec,
+                "timeout_was_clamped": timeout_was_clamped,
+                "message": (
+                    f"Command exceeded timeout (effective_timeout={timeout_s}s). "
+                    "Process was terminated."
+                ),
+            },
+        }
 
 # ---------------------------- apply_patch ----------------------------#
 def _ap_normalize_unicode(s: str) -> str:

henosis_cli-0.6.6.dist-info/RECORD

@@ -1,11 +0,0 @@
-cli.py,sha256=XgyMuIBF-b20rQ2mIAAYDLVxEzZB4-4DlZQ0a4V_1UY,501266
-henosis_cli_tools/__init__.py,sha256=x3uaN_ub32uALx_oURna0VnuoSsj7i9NYY6uRsc2ZzM,1147
-henosis_cli_tools/cli_entry.py,sha256=OZTe_s9Hfy3mcsYG77T3RTdtCDod-CSwmhskbXjmmqs,1713
-henosis_cli_tools/input_engine.py,sha256=kGW6AgDGbdcVxlx5mvTPKYe4lYhho5wztvUAw7WlmTs,15286
-henosis_cli_tools/settings_ui.py,sha256=8rWsp0S3wT-dgkP0y20FOBmBBy7jYbDy8AuftmKcp4w,21368
-henosis_cli_tools/tool_impl.py,sha256=oZGajJMkR2jfyuPVe-iq2s6ktOl5-2K3RzX2R7FIAFQ,37414
-henosis_cli-0.6.6.dist-info/METADATA,sha256=FTcN41P41geCQJDQ3l8gechD9F7V1SwKIzkUB_P98Rg,5787
-henosis_cli-0.6.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-henosis_cli-0.6.6.dist-info/entry_points.txt,sha256=KmXDdmIjq1SVMs8FK3wHPA2i89RMaerzZHIetllMLIk,74
-henosis_cli-0.6.6.dist-info/top_level.txt,sha256=u7XMBcJ8Kb0n91WaSU-4Db8yURSUXFuOxGMsXti0a-g,34
-henosis_cli-0.6.6.dist-info/RECORD,,