gemcode 0.3.107__tar.gz → 0.3.109__tar.gz

{gemcode-0.3.107/src/gemcode.egg-info → gemcode-0.3.109}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.107
+Version: 0.3.109
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License

{gemcode-0.3.107 → gemcode-0.3.109}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gemcode"
-version = "0.3.107"
+version = "0.3.109"
 description = "Local-first coding agent on Google Gemini + ADK"
 readme = "README.md"
 requires-python = ">=3.11"

{gemcode-0.3.107 → gemcode-0.3.109}/src/gemcode/agent.py

@@ -76,6 +76,8 @@ def build_global_instruction() -> str:
     "You are GemCode, an expert software engineering agent powered by Google Gemini. "
     "Think deeply about what the person actually wants before you do anything. "
     "Use exactly as many tools as the task genuinely requires — no more. "
+    "When routing or capabilities change between turns, still prefer minimal tools, "
+    "repo-grounded evidence, and verification before claiming done. "
     "Act fully and autonomously when action is needed. "
     "Always use read-only tools before shell or write tools. "
     "Never create CLAUDE.md or AGENTS.md; use GEMINI.md for project instructions."
@@ -353,6 +355,79 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
 - **Working in subfolders** — call `list_directory(\"Desktop\")`, `glob_files(\"**/query.ts\")`, `read_file(\"testing/ai-edtech-app/src/app/page.tsx\")` directly. Never claim access is blocked unless a tool returned an explicit error.{git_section}{curated_section}{veomem_section}"""
 
 
+def _build_calibration_section(cfg: GemCodeConfig) -> str:
+  """
+  Meta-instruction for "smart" behavior under dynamic routing (auto model/capability mode,
+  orchestration tools, etc.). Kept compact to limit prompt bloat.
+  """
+  mm = (getattr(cfg, "model_mode", "") or "").strip().lower()
+  cm = (getattr(cfg, "capability_mode", "") or "").strip().lower()
+  bits: list[str] = []
+  if mm == "auto":
+    bits.append("`model_mode=auto` (model may shift per turn for speed vs depth)")
+  if cm == "auto":
+    bits.append("`capability_mode=auto` (deep research / extras may attach per turn)")
+  session_note = ""
+  if bits:
+    session_note = (
+      "\n**This session uses dynamic routing:** "
+      + " · ".join(bits)
+      + ". Defaults are **hints** — override with judgment when the task clearly needs more or less depth.\n"
+    )
+
+  return f"""## Calibration and dynamic routing (all modes)
+
+Infer **intent → depth → tools** without fixed buckets (requests vary):
+
+| Stance | Move |
+| --- | --- |
+| **Explain / review** | Read-only recon first; cite **paths**; avoid unrelated edits. |
+| **Implement / fix** | Recon → plan (`todo_write` when 3+ steps) → smallest change → **verify** (tests, lint, build slice, or read-back). |
+| **Debug** | One hypothesis per iteration; change one variable between tries; never repeat the same failing command verbatim. |
+| **External facts** | Use web/research tools when the answer is outside the repo (docs, APIs, CVEs). Prefer **repo files** for how *this* codebase behaves. |
+
+**Evidence:** tie non-obvious claims about this workspace to **files or command output** you actually saw.
+
+**Orchestration:** use `spawn_subtasks`, org delegation, or background jobs only when work is **parallel** or **role-split**. Merge into **one** answer with a single recommendation; skip fan-out for small linear tasks.
+
+**Anti-patterns:** tool spam; “done” without verification on risky edits; searching the web when the source file is already in-tree; repeating identical failures.{session_note}"""
+
+
+def _engineering_discipline_instruction_enabled() -> bool:
+  """Extra prompt section: cautious change quality. Opt out with GEMCODE_ENGINEERING_DISCIPLINE=0."""
+  import os
+
+  v = os.environ.get("GEMCODE_ENGINEERING_DISCIPLINE", "1").strip().lower()
+  return v not in ("0", "false", "no", "off")
+
+
+def _build_engineering_discipline_section(cfg: GemCodeConfig) -> str:
+  """Prompt block for minimal, evidence-grounded edits; trivial fixes need not dwell on it."""
+  _ = cfg  # reserved for future project-scoped tuning
+  return """## Engineering discipline (change quality)
+
+**Tradeoff:** biases toward careful, minimal diffs over speed. For trivial edits, use judgment.
+
+### Ambiguity
+- Briefly state **what you understood** before substantial implementation. If several readings fit, outline them or ask **one** precise question — do not silently pick and run.
+- Prefer **evidence from this repo** (reads, grep, tests) over guessed APIs, paths, or behaviour.
+
+### Scope and simplicity
+- Deliver **what was asked**, not a roadmap of extras. Avoid speculative features, abstraction layers, or configurability “for later” unless the user requested flexibility.
+- Prefer the **smallest** correct change. Expand structure only when complexity is already present or clearly required.
+
+### Surgical edits
+- Change **only** what is necessary for the outcome; match surrounding **style and patterns** unless project docs say otherwise.
+- Do not refactor, rename, or reformat unrelated code in the same pass. Note worthwhile cleanups separately if helpful.
+- Remove **orphans your edit introduced** (e.g. unused imports from your change). Leave pre-existing dead code unless the user asks to remove it.
+
+### When to call it done
+- Turn fuzzy requests into **checkable** outcomes where it matters (e.g. bug → reproduce → fix → same checks green).
+- After material edits, run the **cheapest** falsifying step you can: targeted test, lint, build, or re-read the critical path — not guess-and-hope.
+
+"""
+
+
 def _build_memory_section(cfg: GemCodeConfig) -> str:
   """Injected when enable_memory=True so the agent understands and uses memory."""
   mem_path = cfg.project_root / ".gemcode" / "memories.jsonl"
@@ -559,6 +634,12 @@ def build_instruction(cfg: GemCodeConfig) -> str:
     "on",
   )
 
+  discipline_block = (
+    _build_engineering_discipline_section(cfg)
+    if _engineering_discipline_instruction_enabled()
+    else ""
+  )
+
   base = f"""You are GemCode, an expert software engineering agent powered by Google Gemini.
 You run locally via the GemCode CLI. You are the same agent the user launched — not a hosted portal.
 
@@ -610,6 +691,8 @@ You have native deep thinking capability — use it actively:
 - Prefer **small, targeted tool outputs** by default (saves context, improves accuracy).
 - If a tool output was **offloaded** (you see a `tool_result:<sha>` reference), and you need details, call `load_tool_result(ref)` and extract only the relevant slice.
 
+{_build_calibration_section(cfg)}
+{discipline_block}
 ## Tool selection guide (only when needed)
 
 Keep tool usage minimal. Prefer short, targeted calls and keep tool outputs small.

{gemcode-0.3.107 → gemcode-0.3.109}/src/gemcode/invoke.py

@@ -18,11 +18,6 @@ from google.adk.runners import Runner
 from google.genai import types
 
 
-# Delays (seconds) between successive transient-error retries: 2s, 5s, 12s.
-# Three retries = up to ~19 seconds of total wait before giving up.
-_TRANSIENT_RETRY_DELAYS = [2.0, 5.0, 12.0]
-
-
 _HITL_PROMPT_LOCK = Lock()
 
 async def _maybe_enqueue_kaira_autopilot(*, cfg: "GemCodeConfig", session_id: str) -> None:
@@ -423,14 +418,14 @@ async def run_turn(
             next_message=current_message, do_reset=do_reset
           )
         except Exception as _exc:
-          from gemcode.model_errors import is_transient_error
-          if is_transient_error(_exc) and transient_attempts < len(_TRANSIENT_RETRY_DELAYS):
-            delay = _TRANSIENT_RETRY_DELAYS[transient_attempts]
+          from gemcode.model_errors import API_TRANSIENT_RETRY_DELAYS_SEC, is_transient_error
+          if is_transient_error(_exc) and transient_attempts < len(API_TRANSIENT_RETRY_DELAYS_SEC):
+            delay = API_TRANSIENT_RETRY_DELAYS_SEC[transient_attempts]
             transient_attempts += 1
             _tui_active = os.environ.get("GEMCODE_TUI_ACTIVE", "0").lower() in ("1", "true", "yes", "on")
             _msg = (
               f"\n[gemcode] Transient API error ({type(_exc).__name__}). "
-              f"Retrying in {delay:.0f}s (attempt {transient_attempts}/{len(_TRANSIENT_RETRY_DELAYS)})...\n"
+              f"Retrying in {delay:.0f}s (attempt {transient_attempts}/{len(API_TRANSIENT_RETRY_DELAYS_SEC)})...\n"
             )
             print(_msg, file=sys.stderr)
             # Surface retry notice in TUI if available.

{gemcode-0.3.107 → gemcode-0.3.109}/src/gemcode/model_errors.py

@@ -4,6 +4,9 @@ from __future__ import annotations
 
 import re
 
+# Seconds between retries for transient API failures (shared by invoke.py and TUI).
+API_TRANSIENT_RETRY_DELAYS_SEC: tuple[float, ...] = (2.0, 5.0, 12.0)
+
 
 def is_transient_error(error: Exception) -> bool:
   """Return True for HTTP 503 / 429 and similar transient API errors that are safe to retry.
@@ -29,6 +32,21 @@ def is_transient_error(error: Exception) -> bool:
     return True
 
   msg = str(error)
+  ml = msg.lower()
+
+  # httpx / google-genai often raise ``ServerError`` for HTTP 500 without ``APIError.code``.
+  if et == "ServerError" or "ServerError" in et:
+    if any(code in msg for code in ("500", "502", "503", "504")):
+      return True
+
+  # Gemini REST body shape: ``'code': 500`` / ``"INTERNAL"`` / "Internal error encountered."
+  if ("'code': 500" in msg or '"code": 500' in msg or re.search(r"\b500\b", msg)) and any(
+    p in ml for p in ("internal", "unavailable", "try again", "deadline", "timeout", "backend")
+  ):
+    return True
+  if "internal error encountered" in ml:
+    return True
+
   # Match the specific phrases Gemini uses in 503 responses
   if "503" in msg and any(p in msg for p in ("high demand", "service unavailable", "overloaded")):
     return True

{gemcode-0.3.107 → gemcode-0.3.109}/src/gemcode/repl_commands.py

@@ -378,6 +378,9 @@ def slash_help_lines() -> list[str]:
       "  /audit [N]            Tail of .gemcode/audit.log (default 40 lines)",
       "  /tools                List tool inventory for this config",
       "  /tools smoke          Declaration compile check only (failures listed)",
+      "  /mcp                  MCP status (reads .gemcode/mcp.json; shows loaded toolsets)",
+      "  /mcp list             List configured MCP servers",
+      "  /mcp reload           Rebuild runner to reload MCP toolsets",
       "  /eval [llm]           Run tools_smoke (+ pytest if tests/ exist); optional LLM goldens",
       "  /autotune init <tag>  Git branch autotune/<tag> for experiment tracking",
       "  /autotune eval [llm]  Eval + append .gemcode/evals/autotune_ledger.jsonl",

{gemcode-0.3.107 → gemcode-0.3.109}/src/gemcode/repl_slash.py

@@ -1245,6 +1245,97 @@ async def process_repl_slash(
     out()
     return ReplSlashResult(skip_model_turn=True)
 
+  # ── /mcp (Model Context Protocol toolsets) ────────────────────────────────
+  if name == "mcp":
+    args_m = (sc.args or "").strip()
+    sub = (args_m.split()[0].strip().lower() if args_m else "status")
+    mcp_path = cfg.project_root / ".gemcode" / "mcp.json"
+
+    if sub in ("help", "?"):
+      out("Usage:")
+      out("  /mcp                 Show MCP config + loaded toolsets (same as /mcp status)")
+      out("  /mcp status          Show MCP config + loaded toolsets")
+      out("  /mcp list            List configured servers from .gemcode/mcp.json")
+      out("  /mcp reload          Rebuild runner to reload MCP toolsets from disk")
+      out()
+      out("Config:")
+      out(f"  {mcp_path}")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if sub in ("reload", "refresh"):
+      out("MCP: runner will rebuild on the next turn (reload .gemcode/mcp.json).")
+      out()
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+
+    # Read config if present.
+    servers: list[dict] = []
+    parse_error: str | None = None
+    if mcp_path.is_file():
+      try:
+        import json
+
+        data = json.loads(mcp_path.read_text(encoding="utf-8"))
+        servers = list(data.get("servers") or [])
+      except Exception as e:
+        parse_error = str(e)
+
+    # Inspect currently loaded toolsets (best-effort; depends on how caller wired extra_tools).
+    loaded_prefixes: list[str] = []
+    loaded_count = 0
+    try:
+      from google.adk.tools.mcp_tool.mcp_toolset import McpToolset  # type: ignore
+
+      for t in list(extra_tools or []):
+        if isinstance(t, McpToolset):
+          loaded_count += 1
+          try:
+            p = getattr(t, "tool_name_prefix", None)
+            if isinstance(p, str) and p and p not in loaded_prefixes:
+              loaded_prefixes.append(p)
+          except Exception:
+            pass
+    except Exception:
+      # MCP extras not installed or ADK missing MCP toolset types.
+      pass
+
+    if sub in ("list", "ls"):
+      out(f"mcp.json: {mcp_path} ({'exists' if mcp_path.is_file() else 'missing'})")
+      if parse_error:
+        out(f"error: {parse_error}")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      if not servers:
+        out("(no servers configured)")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      out("Servers:")
+      for s in servers[:200]:
+        try:
+          nm = (s.get("name") or "mcp").strip()
+          kind = "stdio" if "stdio" in s else ("http" if "http" in s else ("sse" if "sse" in s else "?"))
+          out(f"  - {nm} ({kind})")
+        except Exception:
+          continue
+      if len(servers) > 200:
+        out(f"  … (+{len(servers) - 200} more)")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    # Default: status.
+    out("MCP:")
+    out(f"  mcp.json: {mcp_path} ({'exists' if mcp_path.is_file() else 'missing'})")
+    if parse_error:
+      out(f"  parse_error: {parse_error}")
+    out(f"  configured_servers: {len(servers)}")
+    suffix = f"  (prefixes: {', '.join(sorted(loaded_prefixes))})" if loaded_prefixes else ""
+    out(f"  loaded_toolsets:    {loaded_count}{suffix}")
+    out()
+    if not mcp_path.is_file():
+      out("Tip: create .gemcode/mcp.json to enable MCP toolsets for this project.")
+      out()
+    return ReplSlashResult(skip_model_turn=True)
+
   if name == "tools":
     args_t = (sc.args or "").strip().lower()
     if args_t in ("smoke", "decl", "declarations"):

{gemcode-0.3.107 → gemcode-0.3.109}/src/gemcode/session_runtime.py

@@ -31,6 +31,63 @@ from gemcode.plugins.terminal_hooks_plugin import GemCodeTerminalHooksPlugin
 from gemcode.plugins.tool_recovery_plugin import GemCodeReflectAndRetryToolPlugin
 
 
+# ---------------------------------------------------------------------------
+# ADK: Gemini context cache — quiet "stale delete" failures
+# ---------------------------------------------------------------------------
+
+
+def _gemini_cache_delete_already_gone(exc: BaseException) -> bool:
+  """True when delete failed only because the cache entry is already gone.
+
+  The Gemini API often returns ``403 PERMISSION_DENIED`` with a body like
+  ``CachedContent not found`` after TTL expiry or server-side eviction. ADK's
+  default cleanup logs that as WARNING every time — noisy and usually harmless.
+  """
+  msg = str(exc).lower()
+  if "cachedcontent not found" in msg:
+    return True
+  if "not found" in msg and "cached" in msg:
+    return True
+  code = getattr(exc, "code", None)
+  if code == 404:
+    return True
+  status = (getattr(exc, "status", None) or "").upper()
+  if code == 403 and status == "PERMISSION_DENIED" and ("cachedcontent" in msg or "cached content" in msg):
+    return True
+  return False
+
+
+def _patch_gemini_adk_cache_cleanup() -> None:
+  """Downgrade benign cache-delete failures to DEBUG (see ``_gemini_cache_delete_already_gone``)."""
+  try:
+    from google.adk.models import gemini_context_cache_manager as gccm
+  except Exception:
+    return
+  if getattr(gccm.GeminiContextCacheManager, "_gemcode_cleanup_patch", False):
+    return
+
+  async def _cleanup(self, cache_name: str) -> None:
+    gccm.logger.debug("Attempting to delete cache: %s", cache_name)
+    try:
+      await self.genai_client.aio.caches.delete(name=cache_name)
+      gccm.logger.info("Cache cleaned up: %s", cache_name)
+    except BaseException as e:
+      if _gemini_cache_delete_already_gone(e):
+        gccm.logger.debug(
+            "Cache delete no-op (already expired or gone): %s — %s",
+            cache_name,
+            e,
+        )
+        return
+      gccm.logger.warning("Failed to cleanup cache %s: %s", cache_name, e)
+
+  gccm.GeminiContextCacheManager.cleanup_cache = _cleanup  # type: ignore[method-assign]
+  gccm.GeminiContextCacheManager._gemcode_cleanup_patch = True
+
+
+_patch_gemini_adk_cache_cleanup()
+
+
 # ---------------------------------------------------------------------------
 # ADK App-level feature helpers
 # ---------------------------------------------------------------------------

{gemcode-0.3.107 → gemcode-0.3.109}/src/gemcode/tool_prompt_manifest.py

@@ -105,6 +105,30 @@ def build_tool_manifest(cfg: GemCodeConfig) -> str | None:
 
   memory_on = bool(getattr(cfg, "enable_memory", False))
 
+  mm = (getattr(cfg, "model_mode", "") or "").strip().lower()
+  cm = (getattr(cfg, "capability_mode", "") or "").strip().lower()
+  auto_routing_note = ""
+  if mm == "auto" or cm == "auto":
+    auto_routing_note = (
+      f"\n- **Dynamic routing:** `model_mode={mm}`, `capability_mode={cm}` — per-turn defaults are **hints**; "
+      "still pick the smallest depth/toolset that fits the ask.\n"
+    )
+
+  calibration_manifest = f"""### Calibration (aligned with main instruction)
+- **Repo vs external:** ground claims about *this repo* with reads/grep/tests; use research/web for **external** docs, APIs, or facts outside the tree.
+- **Orchestration:** use `run_subtask` / `spawn_subtasks` only for **parallel independent** work or explicit verification; merge into **one** answer; skip fan-out for trivial linear tasks.
+- **Finish line:** verify risky edits (test/lint/read-back) before declaring done.{auto_routing_note}"""
+
+  _disc = os.environ.get("GEMCODE_ENGINEERING_DISCIPLINE", "1").strip().lower()
+  discipline_manifest = ""
+  if _disc not in ("0", "false", "no", "off"):
+    discipline_manifest = """
+
+### Engineering discipline (aligned with main instruction)
+- **Ambiguity:** state what you understood or ask **one** precise question; prefer repo evidence over guesses.
+- **Scope:** deliver the ask with the **smallest** adequate change; skip speculative extras.
+- **Surgical:** touch only what you must; match local style; clean up orphans **your** edit introduced."""
+
   manifest = f"""## Tool system (GemCode)
 
 ### Execution model
@@ -112,6 +136,8 @@ def build_tool_manifest(cfg: GemCodeConfig) -> str | None:
 - **Reason end-to-end autonomously.** The user expects complete tasks, not a questionnaire. Use `think` before complex actions, `todo_write` to track multi-step work.
 - **Never stop after the first tool call succeeds.** Keep going until the full task is done or you hit a genuine blocker.
 
+{calibration_manifest}{discipline_manifest}
+
 ### Permission policy
 | Setting | Value |
 |---------|-------|

{gemcode-0.3.107 → gemcode-0.3.109}/src/gemcode/tool_registry.py

@@ -38,7 +38,9 @@ SHELL_TOOLS: frozenset[str] = frozenset({"run_command", "bash"})
 # Session planning only (no disk / shell; no extra permission)
 # think — in-context reasoning scratchpad (no-op, no side effects)
 # run_subtask — spawns a sub-agent; inherits parent permission settings
-PLANNING_TOOLS: frozenset[str] = frozenset({"todo_write", "think", "run_subtask"})
+PLANNING_TOOLS: frozenset[str] = frozenset(
+  {"todo_write", "think", "run_subtask", "spawn_subtasks"}
+)
 
 ToolConcurrency = Literal["parallel_safe", "serial_mutating", "shell"]
 

{gemcode-0.3.107 → gemcode-0.3.109}/src/gemcode/tui/scrollback.py

@@ -16,6 +16,7 @@ from gemcode.multimodal_input import build_user_content
 
 from gemcode.capability_routing import apply_capability_routing
 from gemcode.config import load_cli_environment
+from gemcode.model_errors import API_TRANSIENT_RETRY_DELAYS_SEC, format_model_error_for_user, is_transient_error
 from gemcode.model_routing import pick_effective_model
 from gemcode.repl_slash import process_repl_slash
 from gemcode.tui.input_handler import GemCodeInputHandler
@@ -915,40 +916,70 @@ async def run_gemcode_scrollback_tui(
       # as different phases of the turn complete.
       _start_anim("Thinking\u2026")
 
-      try:
-        async for ev in runner.run_async(**kwargs):
-          events.append(ev)
-          _render_tool_calls(ev)
-          _render_tool_results(ev)
-          try:
-            if not ev.content or not ev.content.parts:
-              continue
-            # Only skip user turns. ADK often omits `author` on model events — do NOT
-            # skip those or the assistant text never renders (blank reply, ↓0 tokens).
-            if getattr(ev, "author", None) == "user":
-              continue
-            for part in ev.content.parts:
-              delta = getattr(part, "text", None)
-              if not delta:
+      transient_attempts = 0
+      stream_exc: Exception | None = None
+      while True:
+        stream_exc = None
+        try:
+          async for ev in runner.run_async(**kwargs):
+            events.append(ev)
+            _render_tool_calls(ev)
+            _render_tool_results(ev)
+            try:
+              if not ev.content or not ev.content.parts:
                 continue
-              assistant_wrote_text = True
-              if getattr(part, "thought", None):
-                buffered_thought.append(delta)
-              else:
-                buffered_final.append(delta)
-          except Exception:
+              # Only skip user turns. ADK often omits `author` on model events — do NOT
+              # skip those or the assistant text never renders (blank reply, ↓0 tokens).
+              if getattr(ev, "author", None) == "user":
+                continue
+              for part in ev.content.parts:
+                delta = getattr(part, "text", None)
+                if not delta:
+                  continue
+                assistant_wrote_text = True
+                if getattr(part, "thought", None):
+                  buffered_thought.append(delta)
+                else:
+                  buffered_final.append(delta)
+            except Exception:
+              continue
+          break
+        except Exception as _turn_err:
+          if is_transient_error(_turn_err) and transient_attempts < len(
+            API_TRANSIENT_RETRY_DELAYS_SEC
+          ):
+            _stop_anim()
+            delay = API_TRANSIENT_RETRY_DELAYS_SEC[transient_attempts]
+            transient_attempts += 1
+            print(
+              f"\n  {ansi.dim}[gemcode] Transient API error ({type(_turn_err).__name__}). "
+              f"Retrying in {delay:.0f}s ({transient_attempts}/"
+              f"{len(API_TRANSIENT_RETRY_DELAYS_SEC)})…{ansi.reset}\n",
+              flush=True,
+            )
+            await asyncio.sleep(delay)
+            events.clear()
+            assistant_wrote_text = False
+            buffered_thought.clear()
+            buffered_final.clear()
+            last_tool_error = None
+            _start_anim("Retrying\u2026")
             continue
-      except Exception as _turn_err:
+          stream_exc = _turn_err
+          break
+
+      if stream_exc is not None:
         # Catch runner errors (e.g. ADK ValueError from mismatched function
         # response IDs) so a single bad turn doesn't crash the whole TUI.
         _stop_anim()
+        try:
+          hint = format_model_error_for_user(stream_exc)
+        except Exception:
+          hint = f"{type(stream_exc).__name__}: {stream_exc}"
+        print(f"\n  {ansi.blue_warn}[gemcode] turn error: {hint}{ansi.reset}")
         print(
-            f"\n  {ansi.blue_warn}[gemcode] turn error: "
-            f"{type(_turn_err).__name__}: {_turn_err}{ansi.reset}"
-        )
-        print(
-            f"  {ansi.dim}The agent encountered an internal error on this turn. "
-            f"Please send your message again.{ansi.reset}\n"
+            f"  {ansi.dim}If this was a temporary Google API issue, send your message again. "
+            f"Otherwise try /compact, a shorter prompt, or /model to switch model.{ansi.reset}\n"
         )
         break
 

{gemcode-0.3.107 → gemcode-0.3.109/src/gemcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.107
+Version: 0.3.109
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License

{gemcode-0.3.107 → gemcode-0.3.109}/src/gemcode.egg-info/SOURCES.txt

@@ -149,6 +149,7 @@ tests/test_permissions.py
 tests/test_prompt_suggestions.py
 tests/test_repl_commands.py
 tests/test_repl_slash.py
+tests/test_session_runtime_cache.py
 tests/test_skills.py
 tests/test_slash_commands.py
 tests/test_slash_completion_registry.py

gemcode-0.3.109/tests/test_agent_instruction.py

@@ -0,0 +1,76 @@
+from pathlib import Path
+
+from gemcode.agent import build_instruction
+from gemcode.config import GemCodeConfig
+from gemcode.tool_prompt_manifest import build_tool_manifest
+
+
+def test_instruction_includes_runtime_facts(tmp_path: Path) -> None:
+  cfg = GemCodeConfig(project_root=tmp_path, model="gemini-2.5-flash")
+  text = build_instruction(cfg)
+  assert str(tmp_path.resolve()) in text
+  assert "gemini-2.5-flash" in text
+  assert "GEMCODE_MODEL" in text
+
+
+def test_instruction_includes_calibration_section(tmp_path: Path) -> None:
+  cfg = GemCodeConfig(project_root=tmp_path, model="gemini-2.5-flash")
+  text = build_instruction(cfg)
+  assert "Calibration and dynamic routing" in text
+  assert "Orchestration" in text
+
+
+def test_instruction_includes_engineering_discipline_section(tmp_path: Path) -> None:
+  cfg = GemCodeConfig(project_root=tmp_path, model="gemini-2.5-flash")
+  text = build_instruction(cfg)
+  assert "Engineering discipline (change quality)" in text
+
+
+def test_instruction_omits_engineering_discipline_when_disabled(tmp_path: Path, monkeypatch) -> None:
+  monkeypatch.setenv("GEMCODE_ENGINEERING_DISCIPLINE", "0")
+  cfg = GemCodeConfig(project_root=tmp_path, model="gemini-2.5-flash")
+  text = build_instruction(cfg)
+  assert "Engineering discipline (change quality)" not in text
+
+
+def test_tool_manifest_includes_engineering_discipline_aligned_block(tmp_path: Path) -> None:
+  cfg = GemCodeConfig(project_root=tmp_path, model="gemini-2.5-flash")
+  m = build_tool_manifest(cfg)
+  assert m is not None
+  assert "Engineering discipline (aligned with main instruction)" in m
+
+
+def test_tool_manifest_omits_engineering_discipline_when_disabled(tmp_path: Path, monkeypatch) -> None:
+  monkeypatch.setenv("GEMCODE_ENGINEERING_DISCIPLINE", "0")
+  cfg = GemCodeConfig(project_root=tmp_path, model="gemini-2.5-flash")
+  m = build_tool_manifest(cfg)
+  assert m is not None
+  assert "Engineering discipline (aligned with main instruction)" not in m
+
+
+def test_tool_manifest_includes_calibration_aligned_block(tmp_path: Path) -> None:
+  cfg = GemCodeConfig(project_root=tmp_path, model="gemini-2.5-flash")
+  m = build_tool_manifest(cfg)
+  assert m is not None
+  assert "Calibration (aligned with main instruction)" in m
+  assert "spawn_subtasks" in m
+
+
+def test_instruction_notes_auto_routing_when_configured(tmp_path: Path) -> None:
+  cfg = GemCodeConfig(project_root=tmp_path, model="gemini-2.5-flash")
+  cfg.model_mode = "auto"
+  cfg.capability_mode = "auto"
+  text = build_instruction(cfg)
+  assert "dynamic routing" in text
+  assert "model_mode=auto" in text
+  assert "capability_mode=auto" in text
+
+
+def test_instruction_includes_veomem_tool_flow_when_recall_present(tmp_path: Path) -> None:
+  cfg = GemCodeConfig(project_root=tmp_path, model="gemini-2.5-flash")
+  object.__setattr__(cfg, "_veomem_wakeup_text", "<veomem-context>hello</veomem-context>")
+  text = build_instruction(cfg)
+  assert "VeoMem recall" in text
+  assert "veomem_search(query=...)" in text
+  assert "veomem_timeline(id=...)" in text
+  assert "veomem_get_observations(ids=...)" in text

{gemcode-0.3.107 → gemcode-0.3.109}/tests/test_model_errors.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import pytest
 
-from gemcode.model_errors import format_model_error_for_user
+from gemcode.model_errors import format_model_error_for_user, is_transient_error
 
 
 def test_format_generic_exception() -> None:
@@ -13,6 +13,22 @@ def test_format_generic_exception() -> None:
   assert "something broke" in msg
 
 
+def test_is_transient_server_error_500_internal() -> None:
+  """Gemini often surfaces 500 INTERNAL as httpx ServerError, not genai APIError."""
+  msg = (
+    "ServerError: 500 INTERNAL. {'error': {'code': 500, 'message': "
+    "'Internal error encountered.', 'status': 'INTERNAL'}}"
+  )
+  assert is_transient_error(RuntimeError(msg))
+
+
+def test_is_transient_server_error_classname() -> None:
+  class ServerError(Exception):
+    pass
+
+  assert is_transient_error(ServerError("500 something"))
+
+
 def test_format_genai_client_error() -> None:
   try:
     from google.genai import errors as genai_errors