gemcode 0.3.66__tar.gz → 0.3.67__tar.gz

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

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

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

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

{gemcode-0.3.66 → gemcode-0.3.67}/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.67}/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
@@ -532,6 +540,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.67}/src/gemcode/config.py

@@ -137,6 +137,12 @@ 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)
+  )
   # 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.67/src/gemcode/dynamic_policy.py

@@ -0,0 +1,117 @@
+"""
+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
+
+
+@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.
+  """
+  # 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)
+
+  if pct >= 45:
+    mult = 1.4
+    return DynamicCaps(
+      tool_inline_chars=min(24_000, int(base_tool * mult)),
+      read_file_max_bytes=140_000,
+      web_fetch_max_chars=30_000,
+      bash_stdout_chars=30_000,
+      bash_stderr_chars=15_000,
+      run_stdout_chars=30_000,
+      run_stderr_chars=30_000,
+      grep_max_matches=60,
+    )
+
+  if pct >= 20:
+    mult = 1.0
+    return DynamicCaps(
+      tool_inline_chars=min(18_000, int(base_tool * mult)),
+      read_file_max_bytes=80_000,
+      web_fetch_max_chars=20_000,
+      bash_stdout_chars=20_000,
+      bash_stderr_chars=10_000,
+      run_stdout_chars=20_000,
+      run_stderr_chars=20_000,
+      grep_max_matches=40,
+    )
+
+  # Tight
+  mult = 0.6
+  return DynamicCaps(
+    tool_inline_chars=max(2000, int(base_tool * mult)),
+    read_file_max_bytes=35_000,
+    web_fetch_max_chars=10_000,
+    bash_stdout_chars=10_000,
+    bash_stderr_chars=8_000,
+    run_stdout_chars=10_000,
+    run_stderr_chars=10_000,
+    grep_max_matches=20,
+  )
+

{gemcode-0.3.66 → gemcode-0.3.67}/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.67}/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.67}/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.67}/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.67}/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.67}/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.67/src/gemcode.egg-info}/PKG-INFO

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

{gemcode-0.3.66 → gemcode-0.3.67}/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