@tiens.nguyen/gu-cli 1.0.723 → 1.0.724

package/client-expert-api.mjs

@@ -20,6 +20,7 @@
 import { createRequire } from "node:module";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { spawnSurviving, pidOnPort } from "./platform-tools.mjs";
+import { DEFAULT_API_BASE as HOSTED_API_BASE } from "./device-login.mjs";
 import { spawn } from "node:child_process";
 import { writeFile, mkdir, readFile, access } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -64,6 +65,8 @@ export function apiEnv({
   mongoUri = LOCAL_MONGO_URI,
   dbName = LOCAL_DB_NAME,
   base = {},
+  hostedBase = hostedApiBase(),
+  home = homedir(),
 } = {}) {
   return {
     ...base,
@@ -71,9 +74,20 @@ export function apiEnv({
     DATA_BACKEND: "mongo",
     MONGODB_URI: mongoUri,
     MONGODB_DB: dbName,
+    // THE AGENT'S PROMPT SCAFFOLD IS NOT ON THIS MACHINE (task #246). The local API forwards the
+    // worker's request to the hosted API, signed with this machine's gu CLI token, and keeps the
+    // answer in memory only — so private mode needs internet for a turn, and says so when it has
+    // none. No local copy exists to fall back to, by design.
+    PROMPT_SCAFFOLD_UPSTREAM: hostedBase,
+    GU_CLI_TOKEN_FILE: join(home, ".gonext", "cli-token.json"),
   };
 }
 
+/** The hosted gu API — where a Client Expert machine's token is renewed and its scaffold fetched. */
+export function hostedApiBase(env = process.env) {
+  return String(env.GU_TOKEN_API_BASE ?? "").trim() || HOSTED_API_BASE;
+}
+
 /**
  * Is this health body a usable API?
  *

package/gonext_agent_chat.py

@@ -1308,7 +1308,7 @@ def _render_numbered_tool_list(tools) -> str:
     when RAG or a workspace is enabled/disabled) and the numbering is always exactly
     correct, unlike the old manually-incremented counter it replaces. Kept intentionally
     terse — first docstring line only, bare arg names — since the system prompt's own
-    `tool.to_code_prompt()` rendering (see _COMPACT_CODE_SYSTEM_PROMPT) already shows the
+    `tool.to_code_prompt()` rendering (in the API-served prompt scaffold) already shows the
     full typed signature on every model call; this is just a quick-reference index."""
     lines = []
     for i, t in enumerate(tools, 1):
@@ -1722,81 +1722,73 @@ def _looks_like_scratchpad(stripped: str) -> bool:
     return len(_DELIBERATION_RE.findall(stripped)) >= 3
 
 
-# Compact replacement for smolagents' default CodeAgent system prompt. The stock template
-# is ~9.9k chars, dominated by ~6k chars of GENERIC few-shot examples (image captions,
-# Wikipedia, etc.) that are irrelevant to our HTTP/file tools and cost real prompt-eval
-# time every step on a slow coding model. This keeps everything FUNCTIONALLY required —
-# the Thought→Code→Observation loop, the code-blob format + closing tag, the {{tools}}
-# rendering (so exact signatures survive), authorized imports, custom_instructions — plus
-# ONE short worked example, and trims the rest. Jinja vars must match the stock template.
-_COMPACT_CODE_SYSTEM_PROMPT = (
-    "You are an expert assistant who solves the task by writing Python code that calls "
-    "tools. You work in a loop of Thought → Code → Observation.\n\n"
-    "At EACH step:\n"
-    "- Write one 'Thought:' line: what you'll do and which tool.\n"
-    "- Then a code block that OPENS with {{code_block_opening_tag}} and CLOSES with "
-    "{{code_block_closing_tag}}, containing simple Python that calls the tools you need "
-    "and print()s what you want to see.\n"
-    "- BATCH INDEPENDENT CALLS INTO ONE BLOCK. If you already know the arguments for "
-    "several lookups, do them in ONE step and print each under a header — up to about 8 at "
-    "a time, then continue in the next step. Split into separate steps only when an "
-    "argument DEPENDS on a previous Observation.\n"
-    "- Batch LOOKUPS, not changes. If a line raises, the lines after it never run — so "
-    "keep edits, file writes and commands to one per block.\n"
-    "- You then receive the 'Observation:'. Use it to decide the next step. When you have "
-    "the answer, call final_answer(answer) inside a code block.\n\n"
-    "Example — arguments already known, so ONE step does all of it:\n"
-    "Thought: I need these three files before I can change anything.\n"
-    "{{code_block_opening_tag}}\n"
-    'for p in ["src/main.js", "src/api.js", "test/main.test.js"]:\n'
-    '    print("=====", p)\n'
-    "    print(read_file_lines(path=p))\n"
-    "{{code_block_closing_tag}}\n"
-    "Observation: \"===== src/main.js … ===== src/api.js … \"\n\n"
-    "Example — the next call DEPENDS on this result, so it is a separate step:\n"
-    "Thought: I'll read the page the user gave.\n"
-    "{{code_block_opening_tag}}\n"
-    'text = fetch_url("https://example.com")\n'
-    "print(text)\n"
-    "{{code_block_closing_tag}}\n"
-    "Observation: \"Example Domain … \"\n"
-    "Thought: I have the content, so I'll answer.\n"
-    "{{code_block_opening_tag}}\n"
-    'final_answer("The page is Example Domain, a placeholder site.")\n'
-    "{{code_block_closing_tag}}\n\n"
-    "You have access to these tools — call them as plain Python functions with the exact "
-    "signatures shown:\n"
-    "{{code_block_opening_tag}}\n"
-    "{%- for tool in tools.values() %}\n"
-    "{{ tool.to_code_prompt() }}\n"
-    "{% endfor %}\n"
-    "{{code_block_closing_tag}}\n"
-    "{%- if managed_agents and managed_agents.values() | list %}\n"
-    "You can also delegate to team members by calling them like a tool with a 'task' "
-    "string argument:\n"
-    "{{code_block_opening_tag}}\n"
-    "{%- for agent in managed_agents.values() %}\n"
-    "def {{ agent.name }}(task: str) -> str:\n"
-    '    """{{ agent.description }}"""\n'
-    "{% endfor %}\n"
-    "{{code_block_closing_tag}}\n"
-    "{%- endif %}\n\n"
-    "Rules:\n"
-    "1. ALWAYS write a 'Thought:' line, then a code block opening with "
-    "{{code_block_opening_tag}} and closing with {{code_block_closing_tag}} — or you fail.\n"
-    "2. Pass tool arguments directly: calculate(expression=\"2+2\"), NOT as a dict.\n"
-    "3. Use only variables you have defined; state persists between steps.\n"
-    "4. Never re-run a tool call with the exact same parameters.\n"
-    "5. Don't name a variable after a tool (e.g. 'final_answer').\n"
-    "6. Imports are allowed ONLY from: {{authorized_imports}}\n"
-    "7. Don't give up — you are in charge of solving the task.\n"
-    "{%- if custom_instructions %}\n"
-    "{{custom_instructions}}\n"
-    "{%- endif %}\n\n"
-    "Now Begin!"
+# THE CODE-AGENT SCAFFOLD IS NOT IN THIS FILE (task #246). The fixed system prompt — the
+# Thought → Code → Observation rules that replace smolagents' stock ~9.9k-char template — is served
+# by the API (GET /api/worker/prompt-scaffold) and never shipped in the gu package. The worker
+# fetches it once per job; if it cannot, the turn stops with the reason. There is deliberately NO
+# local copy to fall back to: the point is that the text is not on the user's machine.
+#
+# What a scaffold must keep, checked again here after the API checked it: without the code-block
+# tags the model's code is never parsed, without the tool loop no signature is shown, without
+# custom_instructions the per-turn hint is dropped — each fails silently, every turn.
+_SCAFFOLD_REQUIRED = (
+    "{{code_block_opening_tag}}",
+    "{{code_block_closing_tag}}",
+    "tool.to_code_prompt()",
+    "{{authorized_imports}}",
+    "custom_instructions",
 )
 
 
+# The version of the scaffold this job is running — for the log and the prompt record, never the text.
+_PROMPT_SCAFFOLD_VERSION = {"v": None}
+
+
+def _fetch_prompt_scaffold(api_base: str, worker_key: str, name: str = "code-agent"):
+    """The agent's prompt scaffold from the API → (template, version).
+
+    Raises _AgentConfigError with a message the USER reads (it becomes a TURN_FAILED line) when
+    the API cannot be asked, refuses, or sends something unusable. Never returns a default. The
+    message never contains the template itself."""
+    base = (api_base or "").rstrip("/")
+    if not base or not worker_key:
+        raise _AgentConfigError(
+            "The agent's prompt could not be loaded: this worker has no API address or key.")
+    from urllib.parse import urlencode
+    req = urllib.request.Request(
+        f"{base}/api/worker/prompt-scaffold?{urlencode({'name': name})}",
+        headers={"X-Worker-Key": worker_key}, method="GET")
+    try:
+        with urllib.request.urlopen(req, timeout=15, context=_ssl_context()) as resp:
+            data = json.loads(resp.read().decode("utf-8", "replace") or "{}")
+    except urllib.error.HTTPError as he:
+        detail = ""
+        try:
+            detail = str(json.loads(he.read().decode("utf-8", "replace") or "{}").get("error") or "")
+        except Exception:  # noqa: BLE001
+            pass
+        if he.code == 404 and not detail:
+            detail = ("this API is older than the prompt service — update it "
+                      "(`gu api upgrade` on a private-mode machine)")
+        raise _AgentConfigError(
+            f"The agent's prompt could not be loaded (HTTP {he.code})"
+            + (f": {detail}" if detail else ".")) from None
+    except Exception as e:  # noqa: BLE001
+        raise _AgentConfigError(
+            f"The agent's prompt could not be loaded — the API at {base} did not answer "
+            f"({type(e).__name__}). Check that it is running and reachable.") from None
+    template = data.get("template") if isinstance(data, dict) else None
+    version = data.get("version") if isinstance(data, dict) else None
+    if not isinstance(template, str) or not template.strip():
+        raise _AgentConfigError("The agent's prompt could not be loaded: the API sent an empty one.")
+    missing = [p for p in _SCAFFOLD_REQUIRED if p not in template]
+    if missing:
+        raise _AgentConfigError(
+            "The agent's prompt could not be used: it is missing " + ", ".join(missing) + ".")
+    _PROMPT_SCAFFOLD_VERSION["v"] = version
+    return template, version
+
+
 def _usage_field(obj, name):
     """One field off a usage object that may be an attribute bag OR a plain dict — both
     shapes come back from OpenAI-compatible clients depending on the transport."""
@@ -2300,6 +2292,14 @@ def _render_prompt(messages, max_chars: int = 400_000) -> str:
     out = []
     for m in messages or []:
         role, text = _message_role_text(m)
+        if role == "system":
+            # THE SCAFFOLD IS NEVER RECORDED (task #246). The system message IS the API-served
+            # prompt scaffold (rendered with the tool signatures), and this record is stored by
+            # the API and shown on the token-usage page — so it would hand the hidden text to
+            # anyone who opens a step. Its size stays visible, the text does not.
+            v = _PROMPT_SCAFFOLD_VERSION["v"]
+            text = (f"[prompt scaffold{f' v{v}' if v is not None else ''} with the tool signatures — "
+                    f"{len(text)} characters, not shown]")
         out.append(f"───── {role or 'message'} ─────\n{text}")
     rendered = "\n\n".join(out)
     if len(rendered) > max_chars:
@@ -12111,21 +12111,25 @@ def run_agent_chat(cfg):
             agent_kwargs["additional_authorized_imports"] = [
                 "json", "base64", "urllib", "urllib.request", "urllib.error"
             ]
-            # Trim smolagents' ~6k-char generic few-shot examples from the system prompt
-            # (they dominate prompt-eval on a slow coding model) while keeping the tool
-            # rendering + format rules intact. Load the stock templates and swap only the
-            # system_prompt; fall back to the default on any error.
+            # THE SYSTEM PROMPT IS THE API'S SCAFFOLD (task #246): the stock templates are loaded
+            # for everything else (planning, final-answer, managed agents) and ONLY system_prompt
+            # is swapped. No fallback in either direction — a missing scaffold, or stock
+            # templates that will not load, stop the turn with the reason (_AgentConfigError →
+            # TURN_FAILED) instead of quietly running on a different prompt. The version is
+            # logged; the text never is.
+            _scaffold, _scaffold_version = _fetch_prompt_scaffold(worker_api_base, worker_api_key)
             try:
                 import yaml as _yaml
                 import os as _os
                 import smolagents as _sm
-                _tpl = _yaml.safe_load(open(_os.path.join(
-                    _os.path.dirname(_sm.__file__), "prompts", "code_agent.yaml")))
-                _tpl["system_prompt"] = _COMPACT_CODE_SYSTEM_PROMPT
-                agent_kwargs["prompt_templates"] = _tpl
-                _log("using compact CodeAgent system prompt (trimmed few-shot examples)")
+                with open(_os.path.join(_os.path.dirname(_sm.__file__), "prompts", "code_agent.yaml")) as _f:
+                    _tpl = _yaml.safe_load(_f)
             except Exception as _e:  # noqa: BLE001
-                _log(f"compact system prompt unavailable ({_e}); using smolagents default")
+                raise _AgentConfigError(
+                    f"The agent's prompt templates could not be loaded ({type(_e).__name__}).") from None
+            _tpl["system_prompt"] = _scaffold
+            agent_kwargs["prompt_templates"] = _tpl
+            _log(f"prompt scaffold code-agent v{_scaffold_version}")
         agent = _ToolAgent(**agent_kwargs)
         _agent_ref["a"] = agent  # let step_callback trim this agent's step memory (#63)
         # At the step budget the run ends WITHOUT final_answer (_maxsteps_partial hit). Offer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.723",
+  "version": "1.0.724",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",