gemcode 0.3.26__tar.gz → 0.3.28__tar.gz

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

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

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

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

{gemcode-0.3.26 → gemcode-0.3.28}/src/gemcode/agent.py

@@ -58,17 +58,93 @@ def _load_gemini_md(project_root: Path) -> str:
 
 def _build_runtime_facts(cfg: GemCodeConfig) -> str:
   """
-  Injected every session so the model does not hallucinate deployment, permissions,
-  or "how to switch Pro" the way a product-agnostic base prompt would.
+  Injected every session so the model is fully self-aware of its own capabilities,
+  limits, and the environment — not just generic defaults.
   """
   root = cfg.project_root.resolve()
   model = (getattr(cfg, "model", None) or "").strip() or "(default)"
+
+  # ── Active capabilities ──────────────────────────────────────────────────
+  caps: list[str] = []
+  if getattr(cfg, "enable_deep_research", False):
+    dr_extras = " + google_maps_grounding" if getattr(cfg, "enable_maps_grounding", False) else ""
+    caps.append(f"deep_research ON (tools: google_search, url_context{dr_extras})")
+  if getattr(cfg, "enable_embeddings", False):
+    caps.append(f"embeddings ON (tool: semantic_search_files, model: {getattr(cfg, 'embeddings_model', 'default')})")
+  if getattr(cfg, "enable_memory", False):
+    mem_path = root / ".gemcode" / "memories.jsonl"
+    mem_kind = "embedding-backed" if getattr(cfg, "enable_embeddings", False) else "keyword-backed"
+    caps.append(f"memory ON ({mem_kind}, stored at {mem_path}; ADK preload_memory injects relevant memories before each turn)")
+  if getattr(cfg, "enable_computer_use", False):
+    caps.append("computer_use ON (tools: navigate, click_at, type_text_at, browser_screenshot, browser_find_element, etc.)")
+  if not caps:
+    caps.append("none enabled (use /research on, /embeddings on, /memory on, /computer on to enable)")
+  caps_text = "\n".join(f"  - {c}" for c in caps)
+
+  # ── Limits ───────────────────────────────────────────────────────────────
+  max_calls = getattr(cfg, "max_llm_calls", 256) or 256
+  token_budget = getattr(cfg, "token_budget", None)
+  max_session_tokens = getattr(cfg, "max_session_tokens", None)
+  budget_line = f"{max_calls} model↔tool iterations per user message"
+  if token_budget:
+    budget_line += f" · token_budget={token_budget:,} per turn"
+  if max_session_tokens:
+    budget_line += f" · max_session_tokens={max_session_tokens:,}"
+
+  # ── Kairos ────────────────────────────────────────────────────────────────
+  # The user can run `gemcode kairos -C <project>` in a separate terminal to
+  # launch a long-lived scheduler. Jobs submitted to it run concurrently with
+  # the current session. This is useful for background / parallel heavy work.
+  kairos_section = (
+    "- **Kairos background scheduler** — `gemcode kairos -C <project>` launches a "
+    "long-lived daemon that reads prompts from stdin and runs each as an isolated job "
+    "(up to N concurrently). Each job gets `kairos_sleep_ms(ms)` and "
+    "`kairos_enqueue_prompt(prompt, priority, session_id)` tools so the model can "
+    "schedule follow-up work itself. Useful for: bulk file processing, repeated "
+    "polling loops, parallelising large independent tasks. "
+    "Tell the user to open a second terminal and run `gemcode kairos` if a task "
+    "would benefit from background parallelism."
+  )
+
   return f"""## Runtime facts (authoritative for this session)
 - **Project root** — every filesystem tool path is relative to: `{root}`
-- **Model id in use:** `{model}`. In this TUI/REPL you can override it for subsequent turns with `/model use <id>` (use `/model list` to browse IDs). For a full restart you can still use `--model <id>` or env `GEMCODE_MODEL`.
-- **UI banner** phrases such as "GemCode Pro" are **terminal marketing**, not a separate API tier or model you enable from chat.
-- **Env toggles** (`GEMCODE_ENABLE_COMPUTER_USE`, `GEMCODE_MODEL`, etc.) affect only the **OS process** that launched `gemcode`. Pasting `VAR=1` in chat does **not** reconfigure a running session—tell the user to export in their shell, use project `.env`, or restart the CLI.
-- **Working in subfolders** — use tools: e.g. `list_directory("Desktop")`, `glob_files("**/query.ts")`, `read_file("testing/ai-edtech-app/src/app/page.tsx")`, or `run_command` with `cwd_subdir`. Never claim the sandbox cannot reach a subpath unless a tool returned an explicit error."""
+- **Model id in use:** `{model}`. Override mid-session with `/model use <id>` or `/mode fast|balanced|quality|auto`.
+- **Execution budget:** {budget_line}.
+- **Active capabilities:**
+{caps_text}
+- **Capability routing** (`capability_mode={getattr(cfg, 'capability_mode', 'auto')}`): in `auto` mode, GemCode automatically enables deep_research when it detects research-intent keywords in your prompt each turn. You can also type `/research on`, `/embeddings on`, `/memory on`, `/computer on` at the prompt.
+- **Your tool palette can grow mid-session:** if the user enables a capability via a slash command, the runner rebuilds and you get new tools on the next turn.
+- **Memory system:** when `memory ON`, ADK automatically searches `.gemcode/memories.jsonl` and injects relevant past context before each turn. Facts the user tells you in one session can appear in future sessions. You do not need to manage memory explicitly — it is loaded automatically.
+{kairos_section}
+- **UI banner** phrases like "GemCode Pro" are terminal marketing, not a separate API tier.
+- **Env toggles** (`GEMCODE_ENABLE_COMPUTER_USE`, `GEMCODE_MODEL`, etc.) affect only the OS process that launched gemcode. Pasting `VAR=1` in chat does NOT reconfigure a running session—tell the user to export in their shell, use project `.env`, or restart the CLI.
+- **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."""
+
+
+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"
+  kind = "embedding-based (semantic cosine similarity)" if getattr(cfg, "enable_embeddings", False) else "keyword-based"
+  return f"""
+## Persistent Memory System
+Memory is **ON** ({kind}). Stored at: `{mem_path}`
+
+### How it works
+- Before each turn, ADK automatically searches the memory store for relevant past facts and injects them as context — you do not need to call a tool to load them.
+- After each turn, the session is automatically added to memory by the post-turn plugin.
+- The memory file persists across sessions (JSONL, one entry per session).
+
+### What to do with memory
+- **Reference it naturally** — if the injected context mentions past facts ("last time the user's API key was X", "the user prefers TypeScript"), treat that as trusted context.
+- **Update it proactively** — if the user tells you important facts about their project, preferences, or recurring patterns, note them in your response: "I'll remember that for future sessions."
+- **Don't re-explain already-known context** — if the memory already contains the project structure or preferences, skip the discovery step and act on what's known.
+- **Memory is scoped to this project root** — `{cfg.project_root}`. Different project roots have separate memories.
+
+### When memory helps most
+- Long-running projects (user preferences, patterns, recurring tasks)
+- Multi-session workflows (continuing work from a previous day)
+- Team conventions stored once and reused automatically
+"""
 
 
 def _build_computer_use_section(cfg: GemCodeConfig) -> str:
@@ -378,10 +454,13 @@ For tasks where quality matters:
 ## Workspace scope
 All file tools use paths **relative to the project root** (where GemCode was started). The root may be the home folder — subfolders like `Desktop`, `Desktop/code`, `Documents` are inside the sandbox. Call `list_directory("Desktop")` or `glob_files("**/*name*.ts")` instead of assuming access is blocked. Only treat access as denied when a tool returns an explicit `error`."""
 
-  # Inject computer use strategy when the browser is enabled.
+  # Inject capability-specific strategy sections only when those caps are on.
   if getattr(cfg, "enable_computer_use", False):
     base = f"{base}\n\n{_build_computer_use_section(cfg)}"
 
+  if getattr(cfg, "enable_memory", False):
+    base = f"{base}\n\n{_build_memory_section(cfg)}"
+
   tool_manifest = build_tool_manifest(cfg)
   if tool_manifest:
     base = f"{base}\n\n{tool_manifest}"
@@ -409,7 +488,7 @@ def build_root_agent(
   if _tools is not None:
     tools = list(_tools)
   else:
-    tools = build_function_tools(cfg)
+  tools = build_function_tools(cfg)
   if getattr(cfg, "enable_memory", False):
     # ADK preload_memory injects retrieved memories into the next llm_request.
     from google.adk.tools import preload_memory

{gemcode-0.3.26 → gemcode-0.3.28}/src/gemcode/repl_commands.py

@@ -215,4 +215,5 @@ def slash_help_lines() -> list[str]:
       "  Other:",
       "  /permissions          Show permission / HITL settings",
       "  /hooks                Show post-turn hook configuration",
+      "  /kairos               How to launch the background parallel job scheduler",
   ]

{gemcode-0.3.26 → gemcode-0.3.28}/src/gemcode/repl_slash.py

@@ -318,6 +318,45 @@ async def process_repl_slash(
   if name in ("exit", "quit"):
     return ReplSlashResult(exit_repl=True)
 
+  # ── /kairos ───────────────────────────────────────────────────────────────
+  if name == "kairos":
+    args_s = (sc.args or "").strip()
+    out("Kairos — background parallel job scheduler")
+    out()
+    out("What it does:")
+    out("  Runs a long-lived daemon that accepts prompts on stdin and executes")
+    out("  each as an isolated GemCode agent job. Jobs run concurrently (up to")
+    out("  --concurrency N, default 2) in a priority queue.")
+    out()
+    out("How to launch (in a separate terminal):")
+    out(f"  gemcode kairos -C {cfg.project_root}")
+    out("  gemcode kairos -C <project> --concurrency 4 --yes")
+    out("  gemcode kairos -C <project> --model gemini-2.5-pro --deep-research")
+    out()
+    out("Options:")
+    out("  --concurrency N      Max parallel jobs (default: 2)")
+    out("  --default-priority N Priority for stdin jobs (higher = runs first, default: 0)")
+    out("  --yes                Auto-approve mutations (like gemcode --yes)")
+    out("  --model <id>         Override model for all jobs")
+    out("  --model-mode <mode>  fast|balanced|quality|auto")
+    out("  --deep-research      Enable Google Search + URL Context for all jobs")
+    out("  --embeddings         Enable semantic file search for all jobs")
+    out("  --max-llm-calls N    Cap model↔tool iterations per job")
+    out("  --session <uuid>     Share session history with a running gemcode session")
+    out()
+    out("Tools available to jobs (in addition to normal GemCode tools):")
+    out("  kairos_sleep_ms(duration_ms)   — pause this job without blocking others")
+    out("  kairos_enqueue_prompt(prompt, priority, session_id)")
+    out("                                  — the model can queue MORE jobs itself")
+    out()
+    out("Use cases:")
+    out("  - Process N files in parallel: each file → one job")
+    out("  - Polling loop: job sleeps, re-enqueues itself with kairos_enqueue_prompt")
+    out("  - Bulk code generation, test runs, or research across many documents")
+    out("  - Background work while you continue chatting in this session")
+    out()
+    return ReplSlashResult(skip_model_turn=True)
+
   # ── /computer ────────────────────────────────────────────────────────────
   if name in ("computer", "browser"):
     args_s = (sc.args or "").strip().lower()

gemcode-0.3.28/src/gemcode/tool_prompt_manifest.py

@@ -0,0 +1,165 @@
+"""
+Tool system prompt manifest.
+
+Claude Code's "tool system" approach is largely prompt-driven: it provides the
+model a clear, consistent contract about what tools exist, what categories they
+fall into, and what the model is allowed to do with each tool.
+
+GemCode primarily enforces policy via ADK callbacks, but adding a short,
+deterministic tool manifest to the model instruction improves behavior and
+reduces tool-call mistakes.
+
+This module builds a compact manifest string from GemCodeConfig.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Iterable
+
+from gemcode.config import GemCodeConfig
+from gemcode.tool_registry import MUTATING_TOOLS, PLANNING_TOOLS, READ_ONLY_TOOLS, SHELL_TOOLS
+
+
+def _truthy_env(name: str, *, default: bool = False) -> bool:
+  v = os.environ.get(name)
+  if v is None:
+    return default
+  return v.lower() in ("1", "true", "yes", "on")
+
+
+def _cap(s: str, *, max_chars: int) -> str:
+  if len(s) <= max_chars:
+    return s
+  return s[: max_chars - 3] + "..."
+
+
+def _fmt_list(items: Iterable[str]) -> str:
+  xs = [x for x in items if x]
+  xs.sort(key=lambda a: a.lower())
+  return ", ".join(xs)
+
+
+def build_tool_manifest(cfg: GemCodeConfig) -> str | None:
+  """
+  Returns a compact "tool system" section to append to the LLM instruction,
+  or None if disabled.
+  """
+  enabled = _truthy_env("GEMCODE_ENABLE_TOOL_SYSTEM_PROMPT", default=True)
+  if not enabled:
+    return None
+
+  max_chars = int(os.environ.get("GEMCODE_TOOL_SYSTEM_PROMPT_MAX_CHARS", "6000"))
+
+  permission_mode = getattr(cfg, "permission_mode", "default")
+  yes_to_all = bool(getattr(cfg, "yes_to_all", False))
+  interactive_ask_on = bool(getattr(cfg, "interactive_permission_ask", False))
+  sticky_hitl = bool(getattr(cfg, "interactive_hitl_sticky_session", True))
+
+  # Core custom tools.
+  read_only = sorted(READ_ONLY_TOOLS)
+  mutating = sorted(MUTATING_TOOLS)
+  shell = sorted(SHELL_TOOLS)
+  planning = sorted(PLANNING_TOOLS)
+
+  # Deep research built-ins are not always safe to combine; we only describe
+  # what's actually enabled by config.
+  deep_research_on = bool(getattr(cfg, "enable_deep_research", False))
+  embeddings_on = bool(getattr(cfg, "enable_embeddings", False))
+  computer_on = bool(getattr(cfg, "enable_computer_use", False))
+
+  maps_grounding_on = bool(getattr(cfg, "enable_maps_grounding", False))
+  tool_comb_mode = getattr(cfg, "tool_combination_mode", None) or "deep_research"
+
+  allow_cmds = getattr(cfg, "allow_commands", None)
+  allow_cmds_str = ""
+  if allow_cmds:
+    allow_cmds_str = _fmt_list(list(allow_cmds))
+
+  # Provide Gemini 3 tool-context circulation contract (best-effort).
+  # We can't guarantee exact tool combination semantics, but the model can
+  # align expectations with GemCode's behavior.
+  gemini3_combination_contract = (
+    f"tool-context-circulation mode is {tool_comb_mode}. "
+    "When enabled, built-in tool results may appear in context for subsequent function tool calls."
+  )
+
+  mutating_policy_extra = ""
+  if interactive_ask_on:
+    mutating_policy_extra = (
+      " If user_in_run_hitl_prompt_enabled is true, the session will show an inline approval prompt—"
+      "do **not** tell the user to re-run with `--yes`; wait for approval and proceed."
+    )
+  else:
+    mutating_policy_extra = (
+      " If neither --yes nor inline HITL is available, ask the user to re-run with `--yes` when mutations are required."
+    )
+
+  memory_on = bool(getattr(cfg, "enable_memory", False))
+
+  manifest = f"""## Tool system (GemCode)
+
+### Execution model
+- Issue **multiple independent tool calls in one step** (parallel reads, parallel grep, parallel run_subtask). Use sequential calls only when step B needs step A's result.
+- **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.
+
+### Permission policy
+| Setting | Value |
+|---------|-------|
+| permission_mode | {permission_mode} |
+| --yes (auto-approve mutations) | {yes_to_all} |
+| interactive HITL prompt | {interactive_ask_on} |
+| sticky HITL (approve once → whole session) | {sticky_hitl} |
+
+{mutating_policy_extra.strip()}
+
+### Planning & reasoning tools: {_fmt_list(planning)}
+- **`todo_write(todos, merge)`** — in-memory task tracker.
+  - `todos`: list of objects with `id` (str), `content` (str), `status` (one of: `pending`, `in_progress`, `completed`, `cancelled`).
+  - `merge=false` (default): replace the entire list. `merge=true`: upsert by id (update existing, add new, leave others unchanged).
+  - Workflow: create with status=pending at task start → update to in_progress when you begin → completed when done.
+  - Use for ANY task with 3+ distinct steps.
+- **`think(thought)`** — private reasoning scratchpad. Not shown to user. Use before: complex refactors, debugging hypotheses, destructive actions, architecture decisions.
+- **`run_subtask(task, context)`** — spawn an isolated sub-agent with a fresh context window.
+  - Inherits your permissions and tool set (except run_subtask itself — no recursion).
+  - Returns the sub-agent's final text as `result`.
+  - Use for: context-heavy exploration (reading 50+ files), parallel investigation of independent subsystems, verification passes after you finish work.
+  - Always give the sub-agent enough context to work independently; end the task with "Summarise your findings clearly."
+
+### Read-only tools (no permission needed): {_fmt_list(read_only)}
+Use proactively. Never use bash/run_command just to list or read files — these are instant and require zero approval.
+
+### Mutating tools (WRITE/EDIT/DELETE): {_fmt_list(mutating)}
+Require: `--yes` OR inline HITL approval.
+- `write_file(path, content)` — create or overwrite. Always `read_file` first if the file exists.
+- `search_replace(path, old_string, new_string)` — targeted in-place edit. `old_string` must be unique in the file; include 3+ lines of context.
+- `delete_file(path)`, `move_file(src, dest)` — destructive; think before calling.
+
+### Shell tools: {_fmt_list(shell)}
+Require: `--yes` OR inline HITL approval. Allowed commands: {allow_cmds_str or "(default allowlist)"}.
+- `bash(command, timeout_seconds, cwd_subdir, background)` — full shell with pipes, redirects.
+  - `background=true` for dev servers, watchers, long builds.
+  - Use `2>&1 | tail -N` to cap verbose output.
+- `run_command(command, args, cwd_subdir, background, extra_env_keys, extra_env_values)` — single-executable without shell features.
+  - Use `extra_env_keys`/`extra_env_values` for non-interactive environment injection.
+  - Prefer `python -m pip` over `pip` to stay in the active virtualenv.
+
+### Optional capability tools
+| Capability | Status | Tools available |
+|-----------|--------|----------------|
+| Deep research | {'**ON**' if deep_research_on else 'off'} | {('google_search, url_context' + (', google_maps_grounding' if maps_grounding_on else '')) if deep_research_on else '—'} |
+| Embeddings / semantic search | {'**ON**' if embeddings_on else 'off'} | {'semantic_search_files' if embeddings_on else '—'} |
+| Persistent memory | {'**ON**' if memory_on else 'off'} | {'preload_memory (auto-injected), memory loaded from .gemcode/memories.jsonl' if memory_on else '— (enable with /memory on)'} |
+| Browser / computer use | {'**ON**' if computer_on else 'off'} | {'navigate, click_at, type_text_at, browser_screenshot, browser_find_element, scroll_at, key_combination, ...' if computer_on else '— (enable with /computer on)'} |
+
+{gemini3_combination_contract}
+
+Enable any capability mid-session with: `/research on`, `/embeddings on`, `/memory on`, `/computer on`.
+
+### Policy
+If a tool call is rejected, do NOT retry the same mutation without the required user confirmation. Adjust your plan and report clearly.
+"""
+
+  return _cap(manifest, max_chars=max_chars)
+

{gemcode-0.3.26 → gemcode-0.3.28}/src/gemcode/tools/__init__.py

@@ -14,6 +14,22 @@ from gemcode.tools.todo import make_todo_tool
 from gemcode.tools.web import make_web_fetch_tool
 
 
+def _wrap_long_running(fn):
+  """
+  Wrap a function tool with ADK's LongRunningFunctionTool so that long-running
+  operations (npm install, cargo build, pytest, etc.) can run beyond the normal
+  streaming timeout and yield intermediate updates.
+
+  Falls back gracefully to the plain function if google-adk does not support
+  LongRunningFunctionTool in the installed version.
+  """
+  try:
+    from google.adk.tools import LongRunningFunctionTool
+    return LongRunningFunctionTool(fn)
+  except Exception:
+    return fn
+
+
 def build_function_tools(cfg: GemCodeConfig, *, include_subtask: bool = True) -> list:
   read_file, list_directory, glob_files, delete_file, move_file = make_filesystem_tools(cfg)
   grep_content = make_grep_tool(cfg)
@@ -24,6 +40,12 @@ def build_function_tools(cfg: GemCodeConfig, *, include_subtask: bool = True) ->
   think = make_think_tool()
   web_fetch = make_web_fetch_tool()
 
+  # bash and run_command are the most common long-running tools (builds, tests,
+  # installs). Wrap them with LongRunningFunctionTool so ADK can handle slow
+  # processes without hitting streaming timeouts.
+  bash_tool = _wrap_long_running(bash)
+  run_command_tool = _wrap_long_running(run_command)
+
   tools = [
     todo_write,
     think,
@@ -31,8 +53,8 @@ def build_function_tools(cfg: GemCodeConfig, *, include_subtask: bool = True) ->
     list_directory,
     glob_files,
     grep_content,
-    bash,
-    run_command,
+    bash_tool,
+    run_command_tool,
     write_file,
     search_replace,
     move_file,

{gemcode-0.3.26 → gemcode-0.3.28}/src/gemcode/tui/input_handler.py

@@ -55,6 +55,7 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     ("memory",      "Toggle persistent memory  ·  /memory on|off"),
     ("budget",      "Set per-turn token budget  ·  /budget <N>  ·  /budget off"),
     ("limits",      "Show/set execution limits (max_llm_calls, context, etc.)"),
+    ("kairos",      "Background parallel job scheduler — how to run gemcode kairos"),
     ("tools",       "List all tools and their permission categories"),
     ("config",      "Show full active configuration (all fields)"),
     ("permissions", "Show current permission mode (default / strict / yes)"),

{gemcode-0.3.26 → gemcode-0.3.28}/src/gemcode/tui/scrollback.py

@@ -252,15 +252,26 @@ async def run_gemcode_scrollback_tui(
   REQUEST_CONFIRMATION_FC = _ADK_REQUEST_CONFIRMATION
 
   def _get_confirmation_fcs(events: list) -> list[types.FunctionCall]:
-    out: list[types.FunctionCall] = []
-    for ev in events:
+    """Return confirmation FCs from the LAST event that contains them.
+
+    The ADK runner expects function responses only for the function calls
+    in the most recent event.  Sending responses for FCs from earlier events
+    in the same batch raises:
+      ValueError: Last response event should only contain the responses for
+        the function calls in the same function call event.
+    So we scan backwards and return only the first (= last) match.
+    """
+    for ev in reversed(events):
       try:
-        for fc in ev.get_function_calls() or []:
-          if getattr(fc, "name", None) == _ADK_REQUEST_CONFIRMATION:
-            out.append(fc)
+        fcs = [
+          fc for fc in (ev.get_function_calls() or [])
+          if getattr(fc, "name", None) == _ADK_REQUEST_CONFIRMATION
+        ]
+        if fcs:
+          return fcs
       except Exception:
         continue
-    return out
+    return []
 
   def _extract_tool_and_hint(fc: types.FunctionCall) -> tuple[str, str]:
     tool_name = "unknown_tool"
@@ -527,26 +538,40 @@ async def run_gemcode_scrollback_tui(
       # as different phases of the turn complete.
       _start_anim("Thinking\u2026")
 
-      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
-          if not getattr(ev, "author", None) or ev.author == "user":
-            continue
-          for part in ev.content.parts:
-            delta = getattr(part, "text", None)
-            if not delta:
+      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:
-          continue
+            if not getattr(ev, "author", None) or ev.author == "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
+      except Exception as _turn_err:
+        # 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()
+        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"
+        )
+        break
 
       _stop_anim()  # ensure spinner is gone before printing the response
 

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

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

gemcode-0.3.26/src/gemcode/tool_prompt_manifest.py

@@ -1,142 +0,0 @@
-"""
-Tool system prompt manifest.
-
-Claude Code's "tool system" approach is largely prompt-driven: it provides the
-model a clear, consistent contract about what tools exist, what categories they
-fall into, and what the model is allowed to do with each tool.
-
-GemCode primarily enforces policy via ADK callbacks, but adding a short,
-deterministic tool manifest to the model instruction improves behavior and
-reduces tool-call mistakes.
-
-This module builds a compact manifest string from GemCodeConfig.
-"""
-
-from __future__ import annotations
-
-import os
-from typing import Iterable
-
-from gemcode.config import GemCodeConfig
-from gemcode.tool_registry import MUTATING_TOOLS, PLANNING_TOOLS, READ_ONLY_TOOLS, SHELL_TOOLS
-
-
-def _truthy_env(name: str, *, default: bool = False) -> bool:
-  v = os.environ.get(name)
-  if v is None:
-    return default
-  return v.lower() in ("1", "true", "yes", "on")
-
-
-def _cap(s: str, *, max_chars: int) -> str:
-  if len(s) <= max_chars:
-    return s
-  return s[: max_chars - 3] + "..."
-
-
-def _fmt_list(items: Iterable[str]) -> str:
-  xs = [x for x in items if x]
-  xs.sort(key=lambda a: a.lower())
-  return ", ".join(xs)
-
-
-def build_tool_manifest(cfg: GemCodeConfig) -> str | None:
-  """
-  Returns a compact "tool system" section to append to the LLM instruction,
-  or None if disabled.
-  """
-  enabled = _truthy_env("GEMCODE_ENABLE_TOOL_SYSTEM_PROMPT", default=True)
-  if not enabled:
-    return None
-
-  max_chars = int(os.environ.get("GEMCODE_TOOL_SYSTEM_PROMPT_MAX_CHARS", "3200"))
-
-  permission_mode = getattr(cfg, "permission_mode", "default")
-  yes_to_all = bool(getattr(cfg, "yes_to_all", False))
-  interactive_ask_on = bool(getattr(cfg, "interactive_permission_ask", False))
-  sticky_hitl = bool(getattr(cfg, "interactive_hitl_sticky_session", True))
-
-  # Core custom tools.
-  read_only = sorted(READ_ONLY_TOOLS)
-  mutating = sorted(MUTATING_TOOLS)
-  shell = sorted(SHELL_TOOLS)
-  planning = sorted(PLANNING_TOOLS)
-
-  # Deep research built-ins are not always safe to combine; we only describe
-  # what's actually enabled by config.
-  deep_research_on = bool(getattr(cfg, "enable_deep_research", False))
-  embeddings_on = bool(getattr(cfg, "enable_embeddings", False))
-  computer_on = bool(getattr(cfg, "enable_computer_use", False))
-
-  maps_grounding_on = bool(getattr(cfg, "enable_maps_grounding", False))
-  tool_comb_mode = getattr(cfg, "tool_combination_mode", None) or "deep_research"
-
-  allow_cmds = getattr(cfg, "allow_commands", None)
-  allow_cmds_str = ""
-  if allow_cmds:
-    allow_cmds_str = _fmt_list(list(allow_cmds))
-
-  # Provide Gemini 3 tool-context circulation contract (best-effort).
-  # We can't guarantee exact tool combination semantics, but the model can
-  # align expectations with GemCode's behavior.
-  gemini3_combination_contract = (
-    f"tool-context-circulation mode is {tool_comb_mode}. "
-    "When enabled, built-in tool results may appear in context for subsequent function tool calls."
-  )
-
-  mutating_policy_extra = ""
-  if interactive_ask_on:
-    mutating_policy_extra = (
-      " If user_in_run_hitl_prompt_enabled is true, the session will show an inline approval prompt—"
-      "do **not** tell the user to re-run with `--yes`; wait for approval and proceed."
-    )
-  else:
-    mutating_policy_extra = (
-      " If neither --yes nor inline HITL is available, ask the user to re-run with `--yes` when mutations are required."
-    )
-
-  manifest = f"""## Tool system (GemCode)
-
-Model behavior:
-- Issue **multiple tool calls in one assistant step** when calls are independent (e.g. several `read_file`/`glob_files`/`grep_content` in parallel). Use a single tool call when the next action depends on the previous result.
-- **Reason end-to-end:** you decide which tools to call and in what order—the user expects autonomous execution within policy, not a questionnaire.
-
-Permission policy:
-- permission_mode={permission_mode}
-- user_confirmation_provided(--yes)={yes_to_all}
-- user_in_run_hitl_prompt_enabled={interactive_ask_on}
-- session_sticky_hitl={sticky_hitl}: when true, after the user approves **one** tool in this session, further mutating/shell tools may run without re-prompting (set GEMCODE_HITL_STICKY_SESSION=0 to prompt every time).
-
-You may call tools as follows:
-- Session planning / reasoning: {_fmt_list(planning)}.
-  - `todo_write`: in-memory task list (no disk writes). Use for non-trivial multi-step work; merge=true to upsert by id.
-  - `think`: private scratchpad — write reasoning/analysis before risky or complex actions. Not shown to user.
-  - `run_subtask(task, context)`: spawn an isolated sub-agent to handle context-heavy work in parallel or in sequence. Sub-agent inherits your permissions and returns its final text as `result`. Exclude run_subtask from sub-agent by design (no recursion).
-- Read-only tools: {_fmt_list(read_only)}.
-  Use these proactively to locate files and code before asking the user for paths.
-- Mutating tools (WRITE/EDIT/DELETE): {_fmt_list(mutating)}.
-  Only call if user_confirmation_provided(--yes) is true OR user_in_run_hitl_prompt_enabled is true.{mutating_policy_extra}
-- Shell tool (run_command): {_fmt_list(shell)}.
-  Prefer allowlisted commands (GEMCODE_ALLOW_COMMANDS). Allowed={allow_cmds_str or "<none>"}.
-  If the user approves a run_command in the session prompt, that specific invocation may run even when the executable is not on the default list.
-  Only call if user_confirmation_provided(--yes) is true OR user_in_run_hitl_prompt_enabled is true.
-  Notes:
-  - Prefer `python -m pip ...` (or `python3 -m pip ...`) so installs stay in the active virtualenv.
-  - Do not assume sudo/system package manager access.
-  - `run_command` supports `cwd_subdir` (relative path under the project) instead of `cd`/`bash`; use parallel `extra_env_keys` / `extra_env_values` (e.g. ["CI"] and ["1"]) for non-interactive installers; use `background=true` for long-running dev servers.
-
-Optional capability tools:
-- Deep research built-ins are {'ON' if deep_research_on else 'OFF'}.
-  Active built-ins: google_search, url_context{', google_maps' if deep_research_on and maps_grounding_on else ''}.
-  {gemini3_combination_contract}
-- Embeddings semantic retrieval is {'ON' if embeddings_on else 'OFF'}:
-  semantic_search_files.
-- Computer use is {'ON' if computer_on else 'OFF'}:
-  browser automation actions via Computer Use toolset.
-  Only call if permission_mode != strict AND (user_confirmation_provided(--yes) is true OR user_in_run_hitl_prompt_enabled is true).
-
-If a tool call is rejected by policy, do NOT retry the same mutation without the required user confirmation.
-"""
-
-  return _cap(manifest, max_chars=max_chars)
-