zames_pro 2.80.8 → 2.81.1

package/dist/send-telemetry.js

@@ -0,0 +1,99 @@
+// Send TELEMETRY — one JSONL line per agent send, per provider.
+//
+// WHY: the send interval is currently a hand-tuned constant (DeepSeek 15 s,
+// Qwen 4 s, GLM 0) and the real limits are only visible in the OUTCOME of a
+// send: a rate limit, a busy server, a truncated turn. Recording every send
+// with its pause and its outcome turns "what is the limit?" into data instead
+// of a guess, and feeds the adaptive throttle (src/send-throttle.ts).
+//
+// NOTHING about the prompt or the answer is recorded: only timing, the mode
+// flags, and the error code/headers a server returned. The file is rotated so
+// an unattended run cannot grow it without bound.
+//
+// The module is PURE apart from the append/rotate helpers, which take the
+// directory as an argument (unit-tested with a temp dir).
+import fs from 'fs';
+import path from 'path';
+/** One line of the telemetry file (PURE). */
+export function formatSendEvent(e) {
+    return JSON.stringify(e);
+}
+/**
+ * PURE: parse the raw JSONL text into events, skipping a broken line (a
+ * half-written last line is expected after a crash and must not poison the
+ * statistics).
+ */
+export function parseSendEvents(raw) {
+    const out = [];
+    for (const line of String(raw || '').split(String.fromCharCode(10))) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        try {
+            const obj = JSON.parse(t);
+            if (obj && typeof obj === 'object' && typeof obj.outcome === 'string') {
+                out.push(obj);
+            }
+        }
+        catch { }
+    }
+    return out;
+}
+/** PURE: aggregate the last events for the /limits view. */
+export function summarizeSends(events, now = Date.now()) {
+    const within = (ms) => events.filter((e) => {
+        const t = Date.parse(e.at);
+        return Number.isFinite(t) && now - t <= ms;
+    }).length;
+    const blocks = events
+        .filter((e) => e.outcome === 'rate_limit' && typeof e.blockMs === 'number')
+        .map((e) => e.blockMs);
+    const avgBlockMs = blocks.length
+        ? Math.round(blocks.reduce((a, b) => a + b, 0) / blocks.length)
+        : 0;
+    return {
+        last10m: within(10 * 60_000),
+        last30m: within(30 * 60_000),
+        last60m: within(60 * 60_000),
+        rateLimits: events.filter((e) => e.outcome === 'rate_limit').length,
+        avgBlockMs,
+    };
+}
+/** `~/.zames/logs/sends-<provider>.jsonl`. */
+export function sendLogPath(logsDir, provider) {
+    return path.join(logsDir, 'sends-' + provider + '.jsonl');
+}
+/** Keep at most `keep` sends-*.jsonl files (rotate the oldest away). */
+export function rotateSendLogs(logsDir, keep = 5) {
+    try {
+        const files = fs
+            .readdirSync(logsDir)
+            .filter((f) => /^sends-.*\.jsonl$/.test(f))
+            .map((f) => ({ f, t: fs.statSync(path.join(logsDir, f)).mtimeMs }))
+            .sort((a, b) => b.t - a.t);
+        for (const old of files.slice(keep)) {
+            try {
+                fs.unlinkSync(path.join(logsDir, old.f));
+            }
+            catch { }
+        }
+    }
+    catch { }
+}
+/** Append one event. Best-effort: a logging failure never breaks a send. */
+export function appendSendEvent(logsDir, e) {
+    try {
+        fs.mkdirSync(logsDir, { recursive: true });
+        fs.appendFileSync(sendLogPath(logsDir, e.provider), formatSendEvent(e) + String.fromCharCode(10), 'utf-8');
+    }
+    catch { }
+}
+/** Read the recent events for one provider (best-effort, [] on failure). */
+export function readSendEvents(logsDir, provider) {
+    try {
+        return parseSendEvents(fs.readFileSync(sendLogPath(logsDir, provider), 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/send-throttle.js

@@ -0,0 +1,108 @@
+// Adaptive SEND THROTTLE — how long to wait before the next agent send.
+//
+// WHY: a fixed interval is wrong in both directions. Too small and the site
+// answers with a rate limit whose PENALTY grows with the overrun (DeepSeek: a
+// zero-gap burst ran ~30 min, then a ~30 min block). Too large and every turn
+// pays a pause that is usually unnecessary. The throttle learns from the
+// telemetry: it stays below a soft budget, backs off on a real limit and
+// recovers gradually after a run of successes.
+//
+// The module is PURE: it takes the current state and one event and returns the
+// next state + the wait. The browser owns the state, so switching providers or
+// finishing a task does not reset what was learned.
+export const DEFAULT_THROTTLE = {
+    windowMs: 10 * 60_000,
+    // Off until the operator has data: an infinite budget never fires.
+    budget: Number.POSITIVE_INFINITY,
+    recoverAfter: 3,
+    maxMs: 60_000,
+    limitFloorMs: 2000,
+};
+export function initialThrottleState(cfg) {
+    return {
+        intervalMs: Math.max(0, cfg.baseMs),
+        okStreak: 0,
+        blocked: false,
+        blockedAt: 0,
+        forcedWaitMs: 0,
+        recent: [],
+    };
+}
+/** Drop sends older than the window (keeps the state small). */
+function prune(recent, now, windowMs) {
+    return recent.filter((t) => now - t <= windowMs);
+}
+/**
+ * PURE: the wait before the next send, given the state and `now`. A blocked
+ * throttle waits out the forced pause; otherwise the learned interval applies
+ * since the last send.
+ */
+export function nextWaitMs(state, lastSentAt, now) {
+    if (state.forcedWaitMs > 0)
+        return state.forcedWaitMs;
+    if (!lastSentAt)
+        return 0;
+    const gap = state.intervalMs - (now - lastSentAt);
+    return gap > 0 ? gap : 0;
+}
+/**
+ * PURE: fold one telemetry event into the state.
+ *
+ * Rules (the operator's strategy):
+ *  - a soft budget: too many sends in the window GROW the interval smoothly,
+ *    ahead of a ban;
+ *  - a rate limit: wait the server's own Retry-After when present, else the
+ *    configured pause; after it lifts the interval doubles (from a floor);
+ *  - after `recoverAfter` successes in a row the interval halves, down to the
+ *    base.
+ */
+export function applySendEvent(state, event, cfg, now = Date.now()) {
+    const next = { ...state, recent: [...state.recent] };
+    const at = Date.parse(event.at);
+    const stamp = Number.isFinite(at) ? at : now;
+    if (event.outcome === 'ok') {
+        next.recent.push(stamp);
+        next.recent = prune(next.recent, now, cfg.windowMs);
+        next.okStreak = state.okStreak + 1;
+        if (next.okStreak >= cfg.recoverAfter) {
+            next.intervalMs = Math.max(cfg.baseMs, Math.floor(next.intervalMs / 2));
+            next.okStreak = 0;
+        }
+        next.blocked = false;
+        next.blockedAt = 0;
+        next.forcedWaitMs = 0;
+    }
+    else if (event.outcome === 'rate_limit') {
+        next.blocked = true;
+        next.blockedAt = state.blocked ? state.blockedAt || stamp : stamp;
+        next.okStreak = 0;
+        next.forcedWaitMs =
+            typeof event.retryAfterMs === 'number' && event.retryAfterMs > 0
+                ? event.retryAfterMs
+                : cfg.rateLimitWaitMs;
+        const floor = Math.max(cfg.baseMs, cfg.limitFloorMs);
+        next.intervalMs = Math.min(cfg.maxMs, Math.max(next.intervalMs, floor) * 2);
+    }
+    else {
+        // busy / incomplete / guest_limit: not a rate signal, keep the interval.
+        next.recent.push(stamp);
+        next.recent = prune(next.recent, now, cfg.windowMs);
+    }
+    // Soft budget: a smooth growth once the window is over budget.
+    if (Number.isFinite(cfg.budget) && next.recent.length > cfg.budget) {
+        const over = next.recent.length - cfg.budget;
+        next.intervalMs = Math.min(cfg.maxMs, Math.max(next.intervalMs, cfg.baseMs) + over * 1000);
+    }
+    return next;
+}
+/**
+ * PURE: a rate limit was observed and the block ended — record its duration on
+ * the event so the telemetry can average it.
+ */
+export function withBlockDuration(event, blockedAt, liftedAt) {
+    if (event.outcome !== 'rate_limit')
+        return event;
+    if (!blockedAt)
+        return event;
+    return { ...event, blockMs: Math.max(0, liftedAt - blockedAt) };
+}

package/dist/system-prompt.js

@@ -195,7 +195,7 @@ export function renderToolSection(tools) {
         .map((t2) => `### ${t2.name}\n${t2.description}\nParameters: ${JSON.stringify(t2.parameters)}`)
         .join('\n\n');
 }
-export function buildSystemPrompt({ workdir, tools, gitContext = null, locale = 'ru', attachments = [], context = null, selfImprovement = false, }) {
+export function buildSystemPrompt({ workdir, tools, gitContext = null, locale = 'ru', attachments = [], context = null, selfImprovement = false, provider, }) {
     const t = translate(locale);
     const toolDescriptions = renderToolSection(tools);
     // Emit the subagent guidance ONLY when the Task tool is actually in the set
@@ -208,6 +208,27 @@ export function buildSystemPrompt({ workdir, tools, gitContext = null, locale =
     const askUserSection = tools.some((x) => x.name === 'AskUser')
         ? ASKUSER_SECTION
         : '';
+    // GLM runs on chat.z.ai, whose OWN agent mode used to execute tool calls in
+    // a cloud sandbox instead of the operator's machine. The provider neutralises
+    // that mode (see glm-browser.ts), but the model must also be TOLD where it
+    // runs: otherwise it asks for a sandbox ("Limit Sandbox Concurrency") or
+    // claims it ran something it did not.
+    const runtimeSection = provider === 'glm'
+        ? "\n## You run on the OPERATOR'S MACHINE (GLM)\n\n" +
+            "The tools above execute on the operator's computer, in the working " +
+            'directory shown at the top. They are the ONLY way to touch files or ' +
+            'run commands.\n\n' +
+            '- There is NO cloud sandbox for you. Do NOT request or use a z.ai ' +
+            'sandbox/VM; a "Limit Sandbox Concurrency" page is a leftover of the ' +
+            "site's own agent mode and is NOT part of this task.\n" +
+            '- Never claim a command ran unless you emitted its tool call and ' +
+            'received a tool result. If you have not called the tool, say so.\n' +
+            "- Paths like `/home/z/...` or `/mnt/data` are NOT the operator's " +
+            'machine.\n' +
+            '- Do NOT use web search / WebSearch unless the task explicitly asks ' +
+            'for current web information: it is slow, it burns the account quota ' +
+            'and it is not needed to read or edit files.\n'
+        : '';
     const gitSection = gitContext
         ? `\n## Git context\n\n${gitContext}\n`
         : '\n## Git context\n\nNot a git repository (or git is not installed).\n';
@@ -269,7 +290,7 @@ task is done (or when you must ask the operator), not between tool calls.
 You have access to the following tools:
 
 ${toolDescriptions}
-${gitSection}${attachSection}${contextSection}${selfSection}
+${runtimeSection}${gitSection}${attachSection}${contextSection}${selfSection}
 ## Choosing the right tool
 
 Prefer the most specific tool; a wrong choice wastes a turn:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.80.8",
+  "version": "2.81.1",
   "description": "Terminal coding agent that drives a real browser to chat with DeepSeek, Qwen and other web LLMs — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {
@@ -41,7 +41,8 @@
     "render-how": "tsx scripts/render-how-it-works.mts",
     "build:readme": "tsx scripts/build-readme.mts",
     "postinstall": "node scripts/postinstall.mjs",
-    "prepare": "husky"
+    "prepare": "husky",
+    "glm-smoke": "tsx scripts/glm-smoke.mts"
   },
   "keywords": [
     "agent",