gemcode 0.3.66__tar.gz → 0.3.68__tar.gz

{gemcode-0.3.66/src/gemcode.egg-info → gemcode-0.3.68}/PKG-INFO

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

{gemcode-0.3.66 → gemcode-0.3.68}/pyproject.toml

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

{gemcode-0.3.66 → gemcode-0.3.68}/src/gemcode/agent.py

@@ -517,6 +517,10 @@ You have native deep thinking capability — use it actively:
 - When something fails, diagnose (re-read the error, check assumptions) before switching strategy. Do not repeat the same failed call.
 - When asked to analyse or explain something: read the actual files, produce concrete findings, not hypotheses.
 
+## Token efficiency without losing intelligence
+- 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.
+
 ## Tool selection guide (only when needed)
 
 Keep tool usage minimal. Prefer short, targeted calls and keep tool outputs small.

{gemcode-0.3.66 → gemcode-0.3.68}/src/gemcode/callbacks.py

@@ -315,10 +315,18 @@ def make_after_tool_callback(cfg: GemCodeConfig):
     name = getattr(tool, "name", None) or ""
 
     # Offload oversized tool outputs to disk (stable refs) before truncation.
+    # Dynamic caps for tool inline payload size.
+    effective_tool_chars = int(getattr(cfg, "tool_result_max_chars", 0) or 0)
+    try:
+      from gemcode.dynamic_policy import get_dynamic_caps
+      effective_tool_chars = get_dynamic_caps(cfg).tool_inline_chars
+    except Exception:
+      pass
+
     if (
       isinstance(tool_response, dict)
       and getattr(cfg, "tool_result_offload_enabled", False)
-      and getattr(cfg, "tool_result_max_chars", 0) > 0
+      and effective_tool_chars > 0
     ):
       try:
         from gemcode.tool_result_store import maybe_offload_tool_result
@@ -326,7 +334,7 @@ def make_after_tool_callback(cfg: GemCodeConfig):
           project_root=cfg.project_root,
           tool_name=name,
           payload=tool_response,
-          max_inline_chars=int(cfg.tool_result_max_chars),
+          max_inline_chars=int(effective_tool_chars),
         )
         if did and isinstance(new_payload, dict):
           tool_response = new_payload
@@ -334,9 +342,9 @@ def make_after_tool_callback(cfg: GemCodeConfig):
       except Exception:
         pass
 
-    if isinstance(tool_response, dict) and getattr(cfg, "tool_result_max_chars", 0) > 0:
+    if isinstance(tool_response, dict) and effective_tool_chars > 0:
       new_d, did = truncate_tool_result_dict(
-          tool_response, int(cfg.tool_result_max_chars)
+          tool_response, int(effective_tool_chars)
       )
       if did:
         tool_response = new_d
@@ -376,6 +384,25 @@ def make_after_tool_callback(cfg: GemCodeConfig):
         st[_STATE_FAILURE_KEY] = 0
     else:
       st[_STATE_FAILURE_KEY] = 0
+
+    # Risk feedback: if tools are failing or commands return non-zero, treat the
+    # task as higher-risk and allow more evidence in subsequent tool outputs.
+    try:
+      cur = float(getattr(cfg, "_risk_score", 0.0) or 0.0)
+      bump = 0.0
+      if err:
+        bump += 0.15
+      if isinstance(tool_response, dict) and isinstance(tool_response.get("exit_code"), int):
+        if int(tool_response["exit_code"]) != 0:
+          bump += 0.10
+      # decay slowly when things are healthy
+      if bump == 0.0:
+        cur = max(0.0, cur * 0.90)
+      else:
+        cur = min(1.0, cur + bump)
+      object.__setattr__(cfg, "_risk_score", cur)
+    except Exception:
+      pass
     # ── Shell hooks: post_tool_use ────────────────────────────────────────
     try:
       from gemcode.hooks import run_post_tool_use_hook
@@ -532,6 +559,14 @@ def make_after_model_callback(cfg: GemCodeConfig):
         st[_LAST_PROMPT_TOKENS] = pt
         st[_LAST_CONTEXT_PCT] = cw.get("percent_left")
         st[_LAST_CONTEXT_LEVEL] = level
+        # Expose to tool layer (dynamic token policy).
+        try:
+          pct = cw.get("percent_left")
+          if isinstance(pct, int):
+            object.__setattr__(cfg, "_context_percent_left", pct)
+          object.__setattr__(cfg, "_context_alert_level", int(level))
+        except Exception:
+          pass
         append_audit(
             cfg.project_root,
             {

{gemcode-0.3.66 → gemcode-0.3.68}/src/gemcode/config.py

@@ -137,6 +137,22 @@ class GemCodeConfig:
   tool_result_offload_enabled: bool = field(
     default_factory=lambda: _truthy_env("GEMCODE_TOOL_RESULT_OFFLOAD", default=True)
   )
+
+  # Dynamic token policy: adapt tool output caps to context pressure so we stay
+  # cheap when context is tight, but remain evidence-rich when there's room.
+  dynamic_token_policy: bool = field(
+    default_factory=lambda: _truthy_env("GEMCODE_DYNAMIC_TOKEN_POLICY", default=True)
+  )
+
+  # Dynamic risk policy: boosts caps when the current task appears risky/complex.
+  dynamic_risk_policy: bool = field(
+    default_factory=lambda: _truthy_env("GEMCODE_DYNAMIC_RISK_POLICY", default=True)
+  )
+
+  # How much the risk score can expand caps (0.0-1.5 reasonable).
+  dynamic_risk_boost: float = field(
+    default_factory=lambda: float(os.environ.get("GEMCODE_DYNAMIC_RISK_BOOST", "0.6"))
+  )
   # Trim oldest text in llm_request.contents when over budget (see context_budget.py).
   context_shrink_enabled: bool = field(
     default_factory=lambda: _truthy_env("GEMCODE_CONTEXT_SHRINK", default=True)

gemcode-0.3.68/src/gemcode/dynamic_policy.py

@@ -0,0 +1,143 @@
+"""
+Dynamic token budgeting / caps.
+
+Optimization must not make the agent dumb:
+- When context pressure is low, allow richer tool outputs and wider reads.
+- When context pressure is high, tighten caps and offload aggressively.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+def _truthy(v: Any, *, default: bool = False) -> bool:
+  if v is None:
+    return default
+  if isinstance(v, bool):
+    return v
+  if isinstance(v, str):
+    return v.lower() in ("1", "true", "yes", "on")
+  return bool(v)
+
+
+def _pct_left(cfg) -> int | None:
+  try:
+    v = getattr(cfg, "_context_percent_left", None)
+    if isinstance(v, int):
+      return v
+  except Exception:
+    return None
+  return None
+
+
+def _risk(cfg) -> float:
+  try:
+    v = getattr(cfg, "_risk_score", None)
+    if isinstance(v, (int, float)):
+      return float(v)
+  except Exception:
+    return 0.0
+  return 0.0
+
+
+def _clamp(x: float, lo: float, hi: float) -> float:
+  return lo if x < lo else hi if x > hi else x
+
+
+@dataclass(frozen=True)
+class DynamicCaps:
+  tool_inline_chars: int
+  read_file_max_bytes: int
+  web_fetch_max_chars: int
+  bash_stdout_chars: int
+  bash_stderr_chars: int
+  run_stdout_chars: int
+  run_stderr_chars: int
+  grep_max_matches: int
+
+
+def get_dynamic_caps(cfg) -> DynamicCaps:
+  """
+  Compute caps based on current context pressure.
+
+  Policy:
+  - Healthy (>=45% left): generous caps (better evidence, less re-asking).
+  - Warning (20-44%): moderate caps.
+  - Tight (<20%): strict caps + prefer offload.
+
+  Then apply a risk-based boost (if enabled) so complex tasks stay evidence-rich.
+  """
+  # cfg can be None in some tool contexts; treat as enabled with defaults.
+  enabled = _truthy(getattr(cfg, "dynamic_token_policy", True) if cfg is not None else True, default=True)
+  if not enabled:
+    # Essentially "no-op" high caps; tools still apply their explicit maxes.
+    return DynamicCaps(
+      tool_inline_chars=int(getattr(cfg, "tool_result_max_chars", 12000) or 12000),
+      read_file_max_bytes=200_000,
+      web_fetch_max_chars=40_000,
+      bash_stdout_chars=80_000,
+      bash_stderr_chars=20_000,
+      run_stdout_chars=50_000,
+      run_stderr_chars=50_000,
+      grep_max_matches=80,
+    )
+
+  pct = _pct_left(cfg) if cfg is not None else None
+  if pct is None:
+    pct = 35
+
+  # Base knobs from config (so users can still tune globally).
+  base_tool = int(getattr(cfg, "tool_result_max_chars", 12000) or 12000) if cfg is not None else 12000
+  base_tool = max(1000, base_tool)
+
+  # Risk boost: scale caps upward for risky tasks, but keep bounded.
+  risk_enabled = _truthy(getattr(cfg, "dynamic_risk_policy", True) if cfg is not None else True, default=True)
+  risk_boost = float(getattr(cfg, "dynamic_risk_boost", 0.6) if cfg is not None else 0.6)
+  risk_score = _risk(cfg) if (cfg is not None and risk_enabled) else 0.0
+  risk_score = _clamp(risk_score, 0.0, 1.0)
+  boost = 1.0 + (_clamp(risk_boost, 0.0, 1.5) * risk_score)
+
+  def _scale(n: int, *, cap: int) -> int:
+    return min(cap, max(1000, int(n * boost)))
+
+  if pct >= 45:
+    mult = 1.4
+    return DynamicCaps(
+      tool_inline_chars=_scale(min(24_000, int(base_tool * mult)), cap=30_000),
+      read_file_max_bytes=min(200_000, int(140_000 * boost)),
+      web_fetch_max_chars=min(60_000, int(30_000 * boost)),
+      bash_stdout_chars=min(80_000, int(30_000 * boost)),
+      bash_stderr_chars=min(40_000, int(15_000 * boost)),
+      run_stdout_chars=min(80_000, int(30_000 * boost)),
+      run_stderr_chars=min(80_000, int(30_000 * boost)),
+      grep_max_matches=min(200, int(60 * boost)),
+    )
+
+  if pct >= 20:
+    mult = 1.0
+    return DynamicCaps(
+      tool_inline_chars=_scale(min(18_000, int(base_tool * mult)), cap=24_000),
+      read_file_max_bytes=min(160_000, int(80_000 * boost)),
+      web_fetch_max_chars=min(40_000, int(20_000 * boost)),
+      bash_stdout_chars=min(50_000, int(20_000 * boost)),
+      bash_stderr_chars=min(30_000, int(10_000 * boost)),
+      run_stdout_chars=min(50_000, int(20_000 * boost)),
+      run_stderr_chars=min(50_000, int(20_000 * boost)),
+      grep_max_matches=min(120, int(40 * boost)),
+    )
+
+  # Tight
+  mult = 0.6
+  return DynamicCaps(
+    tool_inline_chars=max(2000, min(12_000, int(base_tool * mult * boost))),
+    read_file_max_bytes=min(90_000, int(35_000 * boost)),
+    web_fetch_max_chars=min(20_000, int(10_000 * boost)),
+    bash_stdout_chars=min(25_000, int(10_000 * boost)),
+    bash_stderr_chars=min(20_000, int(8_000 * boost)),
+    run_stdout_chars=min(25_000, int(10_000 * boost)),
+    run_stderr_chars=min(25_000, int(10_000 * boost)),
+    grep_max_matches=min(80, int(20 * boost)),
+  )
+

{gemcode-0.3.66 → gemcode-0.3.68}/src/gemcode/invoke.py

@@ -68,6 +68,32 @@ async def run_turn(
     cfg: "GemCodeConfig | None" = None,
 ) -> list:
   """Execute one user message; collect all Events (caller aggregates text)."""
+  # Dynamic risk score: updated each user message; later refined by tool outcomes.
+  # This is intentionally heuristic but configurable via env knobs.
+  if cfg is not None:
+    try:
+      import re
+      p = (prompt or "")[:20_000]
+      risk = 0.0
+      # Complexity signals
+      if len(p) > 600:
+        risk += 0.15
+      if len(p) > 2000:
+        risk += 0.15
+      if re.search(r"\\b(refactor|migrate|rewrite|optimi[sz]e|architecture)\\b", p, re.I):
+        risk += 0.2
+      if re.search(r"\\b(bug|fix|regression|error|traceback|failing)\\b", p, re.I):
+        risk += 0.2
+      if re.search(r"\\b(test|pytest|ci|build|deploy|release)\\b", p, re.I):
+        risk += 0.1
+      # Multi-file hints
+      if p.count(\"/\") >= 6 or p.count(\".py\") + p.count(\".ts\") + p.count(\".tsx\") >= 3:
+        risk += 0.1
+      # Clamp 0..1
+      risk = max(0.0, min(1.0, float(risk)))
+      object.__setattr__(cfg, \"_risk_score\", risk)
+    except Exception:
+      pass
   run_config = (
     RunConfig(max_llm_calls=max_llm_calls) if max_llm_calls is not None else None
   )

{gemcode-0.3.66 → gemcode-0.3.68}/src/gemcode/tools/__init__.py

@@ -84,6 +84,12 @@ def build_function_tools(cfg: GemCodeConfig, *, include_subtask: bool = True) ->
   load_tool_result = _make_load_tool_result_tool(cfg)
   repo_map = make_repo_map_tool(cfg)
 
+  # Attach cfg for dynamic policy inside web_fetch (no cfg param in signature).
+  try:
+    setattr(web_fetch, "_cfg", cfg)
+  except Exception:
+    pass
+
   # 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.

{gemcode-0.3.66 → gemcode-0.3.68}/src/gemcode/tools/bash.py

@@ -182,8 +182,21 @@ def make_bash_tool(cfg: GemCodeConfig):
                 env=env,
                 check=False,
             )
-            stdout = proc.stdout[:20_000]
-            stderr = proc.stderr[:10_000]
+            try:
+                from gemcode.dynamic_policy import get_dynamic_caps
+                caps = get_dynamic_caps(cfg)
+                stdout_cap = caps.bash_stdout_chars
+                stderr_cap = caps.bash_stderr_chars
+            except Exception:
+                stdout_cap = 20_000
+                stderr_cap = 10_000
+
+            # Keep more stderr when failing; it is usually the most informative.
+            if proc.returncode != 0:
+                stderr_cap = max(stderr_cap, 12_000)
+
+            stdout = proc.stdout[:stdout_cap]
+            stderr = proc.stderr[:stderr_cap]
             result: dict = {
                 "command": command,
                 "cwd": str(exec_cwd.relative_to(root)) if exec_cwd != root else ".",

{gemcode-0.3.66 → gemcode-0.3.68}/src/gemcode/tools/filesystem.py

@@ -43,6 +43,15 @@ def make_filesystem_tools(cfg: GemCodeConfig):
       return {"error": str(e)}
     if not p.is_file():
       return {"error": f"Not a file: {path}"}
+
+    # Dynamic caps: allow bigger reads when context is healthy, tighten when tight.
+    try:
+      from gemcode.dynamic_policy import get_dynamic_caps
+      caps = get_dynamic_caps(cfg)
+      if isinstance(max_bytes, int) and max_bytes > caps.read_file_max_bytes:
+        max_bytes = caps.read_file_max_bytes
+    except Exception:
+      pass
     total_bytes = p.stat().st_size
     data = p.read_bytes()
     text_full = data.decode("utf-8", errors="replace")

{gemcode-0.3.66 → gemcode-0.3.68}/src/gemcode/tools/search.py

@@ -61,6 +61,15 @@ def make_grep_tool(cfg: GemCodeConfig):
         Issue multiple grep_content calls in the same turn when searching for
         different patterns — they run in parallel.
         """
+        # Dynamic caps: allow richer search when context is healthy.
+        try:
+            from gemcode.dynamic_policy import get_dynamic_caps
+            caps = get_dynamic_caps(cfg)
+            if isinstance(max_matches, int) and max_matches > caps.grep_max_matches:
+                max_matches = caps.grep_max_matches
+        except Exception:
+            pass
+
         if max_matches < 1:
             max_matches = 1
         if max_matches > 500:

{gemcode-0.3.66 → gemcode-0.3.68}/src/gemcode/tools/shell.py

@@ -157,12 +157,20 @@ def make_run_command(cfg: GemCodeConfig):
           env=child_env,
           check=False,
       )
+      try:
+        from gemcode.dynamic_policy import get_dynamic_caps
+        caps = get_dynamic_caps(cfg)
+        out_cap = caps.run_stdout_chars
+        err_cap = caps.run_stderr_chars
+      except Exception:
+        out_cap = 20_000
+        err_cap = 20_000
       return {
           "command": [exe, *args],
           "cwd": str(exec_cwd.relative_to(root)) if exec_cwd != root else ".",
           "exit_code": proc.returncode,
-          "stdout": proc.stdout[:20_000],
-          "stderr": proc.stderr[:20_000],
+          "stdout": proc.stdout[:out_cap],
+          "stderr": proc.stderr[:err_cap],
       }
     except subprocess.TimeoutExpired:
       return {"error": f"Timeout after {timeout_seconds}s"}

{gemcode-0.3.66 → gemcode-0.3.68}/src/gemcode/tools/web.py

@@ -71,6 +71,18 @@ def make_web_fetch_tool():
         url = url.strip()
         if not url.startswith(("http://", "https://")):
             return {"error": "Only http:// and https:// URLs are supported"}
+        try:
+            from gemcode.dynamic_policy import get_dynamic_caps
+            caps = get_dynamic_caps(getattr(web_fetch, "_cfg", None) or None)  # type: ignore[arg-type]
+        except Exception:
+            caps = None
+        try:
+            # make_web_fetch_tool() has no cfg, so we attach one in the builder.
+            # If present, apply the dynamic cap.
+            if caps is not None and max_chars > getattr(caps, "web_fetch_max_chars", 20_000):
+                max_chars = int(getattr(caps, "web_fetch_max_chars", 20_000))
+        except Exception:
+            pass
         if max_chars < 1000:
             max_chars = 1000
         if max_chars > 200_000:

{gemcode-0.3.66 → gemcode-0.3.68/src/gemcode.egg-info}/PKG-INFO

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

{gemcode-0.3.66 → gemcode-0.3.68}/src/gemcode.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ src/gemcode/config.py
 src/gemcode/context_budget.py
 src/gemcode/context_warning.py
 src/gemcode/credentials.py
+src/gemcode/dynamic_policy.py
 src/gemcode/hitl_session.py
 src/gemcode/hooks.py
 src/gemcode/intent_classifier.py