@tea-agent/loop-agent 0.42.0-next.1 → 0.42.0-next.10

package/dist/executors/pi-executor.js

@@ -1014,17 +1014,28 @@ export function classifyPiFailure(input) {
     if (input.outputTooLarge)
         return "output-too-large";
     const combined = `${input.stderr}\n${input.stdout}`.toLowerCase();
+    // Context overflow (400 request-too-large / context window exceeded).
+    // Must be detected BEFORE the generic rate-limit/quota phrases: an overflow
+    // error often contains "too many tokens" / "maximum context" which would
+    // otherwise be misread as rate-limit or quota. Kept in sync with
+    // CONTEXT_OVERFLOW_PHRASES in commands/client-recovery.ts.
+    if (/请求上下文过大|context_length_exceeded|context overflow|context length overflow|too many tokens|maximum context|prompt is too long|request_too_large|context window/.test(combined))
+        return "context-overflow";
     // Prefer explicit rate-limit / HTTP 429 before generic "limit" quota phrases.
     // Chinese gateways often say "请求频率已达到限制" without English "rate limit".
-    if (/rate.?limit|too many requests|\b429\b|请求频率|频率.*限制|rpm|tpm/.test(combined))
+    // Patterns need error-shaped context: the captured stream also contains
+    // serialized session events, where a bare "429" is an output-token counter,
+    // bare "rpm"/"tpm" are base64 substrings of encrypted reasoning, and bare
+    // "network" is a "no-network" UI state name.
+    if (/rate.?limit|too many requests|(?:http|status)[^\d]{0,4}429\b|"code"\s*:\s*"?429\b|(?:^|\n)429[\s:]|请求频率|频率.*限制|\b(?:rpm|tpm)\s*(?:limit|quota|exceeded)/.test(combined))
         return "rate-limit";
-    if (/quota|usage limit|reached.*limit|5\s*小时|5小时|insufficient_quota|billing/.test(combined))
+    if (/quota|usage limit|reached[^\n.]{0,60}limit|5\s*小时|5小时|insufficient_quota|billing/.test(combined))
         return "quota";
     if (/\bunauthorized\b|\bhttp\s*40[13]\b|invalid api key|authentication (?:failed|required|error)|auth(?:entication)? failed/.test(combined))
         return "auth";
-    if (/unknown provider|unknown model|model.*unavailable|provider.*unavailable|\bunavailable\b|overloaded|capacity|temporarily unavailable/.test(combined))
+    if (/unknown provider|unknown model|(?:provider|model|service|gateway)\s+(?:is\s+)?unavailable|overloaded|at capacity|temporarily unavailable/.test(combined))
         return "unavailable";
-    if (/network|econnreset|etimedout|socket hang up|connection reset|connection error|request timed out|dns|fetch failed/.test(combined))
+    if (/network\s*(?:error|failure|issue|timeout|unreachable|reset|abort)|networkerror|connection (?:reset|error|refused|closed|timed\s*out)|request timed out|socket hang up|econn\w*|etimedout|fetch failed|dns (?:error|failure|lookup failed)/.test(combined))
         return "network";
     if (input.exitCode === 0 && !input.assistantText.trim())
         return "empty-output";

package/dist/executors/pi-read-budget-policy.js

@@ -0,0 +1,239 @@
+import { access, open, readFile, stat, } from "node:fs/promises";
+import path from "node:path";
+class PiReadBudgetSoftLimitError extends Error {
+}
+class PiReadAccessDeniedError extends Error {
+}
+class PiReadBudgetGuard {
+    budget;
+    files = new Set();
+    violations = [];
+    bytes = 0;
+    operations = 0;
+    startedAt = Date.now();
+    allowedReadPaths;
+    allowedReadRoots;
+    constructor(budget, readAccess) {
+        this.budget = budget;
+        this.allowedReadPaths = readAccess?.allowedReadPaths
+            ? new Set(readAccess.allowedReadPaths.map((candidate) => path.resolve(candidate)))
+            : undefined;
+        this.allowedReadRoots = (readAccess?.allowedReadRoots ?? []).map((candidate) => path.resolve(candidate));
+    }
+    issues() {
+        return [...this.violations];
+    }
+    report(message) {
+        if (!this.violations.includes(message))
+            this.violations.push(message);
+    }
+    exhaust(message) {
+        if (this.budget.onExhaustion === "return-guidance") {
+            throw new PiReadBudgetSoftLimitError(message);
+        }
+        this.report(message);
+        throw new Error(message);
+    }
+    assertElapsed() {
+        if (this.budget.maxMs === undefined)
+            return;
+        const elapsedMs = Date.now() - this.startedAt;
+        if (elapsedMs > this.budget.maxMs) {
+            const message = `read budget exhausted: ${elapsedMs}ms (budget ${this.budget.maxMs}ms)`;
+            this.exhaust(message);
+        }
+    }
+    beforeToolOperation() {
+        this.assertElapsed();
+        if (this.budget.maxOperations === undefined)
+            return true;
+        if (this.operations >= this.budget.maxOperations) {
+            const message = `read budget exhausted: operation ${this.operations + 1} would exceed ${this.budget.maxOperations} read-only tool calls`;
+            if (this.budget.onExhaustion === "return-guidance")
+                return false;
+            this.exhaust(message);
+        }
+        this.operations += 1;
+        return true;
+    }
+    operationLimitGuidance() {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "[read limit reached: no repository data was read. Do not call discovery tools again; use injected facts, commit remaining record_* facts, then call finalize_plan exactly once.]",
+                },
+            ],
+        };
+    }
+    readAccessGuidance() {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "[read denied: this node may read only named upstream artifacts or Scout-confirmed paths. Do not explore a new repository path; use committed facts or record an evidence gap, then finish the required terminal protocol.]",
+                },
+            ],
+        };
+    }
+    assertReadablePath(absolutePath) {
+        if (!this.allowedReadPaths)
+            return;
+        const resolved = path.resolve(absolutePath);
+        if (this.allowedReadPaths.has(resolved))
+            return;
+        if (this.allowedReadRoots.some((root) => resolved === root || resolved.startsWith(`${root}${path.sep}`)))
+            return;
+        throw new PiReadAccessDeniedError(`read access denied: ${resolved}`);
+    }
+    reserveFile(absolutePath) {
+        this.assertElapsed();
+        if (this.files.has(absolutePath))
+            return;
+        if (this.files.size >= this.budget.maxFiles) {
+            const message = `read budget exhausted: file ${absolutePath} would exceed ${this.budget.maxFiles} files`;
+            this.exhaust(message);
+        }
+        this.files.add(absolutePath);
+    }
+    reserveBytes(bytes) {
+        this.assertElapsed();
+        const remaining = Math.max(0, this.budget.maxBytes - this.bytes);
+        if (remaining === 0) {
+            const message = `read budget exhausted: ${this.bytes} bytes (budget ${this.budget.maxBytes})`;
+            this.exhaust(message);
+        }
+        const granted = Math.min(bytes, remaining);
+        if (granted < bytes && this.budget.onExhaustion === "return-guidance") {
+            this.exhaust(`read budget exhausted: ${bytes} requested bytes would exceed ${this.budget.maxBytes} bytes`);
+        }
+        this.bytes += granted;
+        if (granted < bytes) {
+            this.report(`read budget truncated: ${bytes} requested bytes at ${this.bytes}/${this.budget.maxBytes} bytes`);
+        }
+        return granted;
+    }
+    async readFile(absolutePath) {
+        this.assertReadablePath(absolutePath);
+        this.reserveFile(absolutePath);
+        const metadata = await stat(absolutePath);
+        const granted = this.reserveBytes(metadata.size);
+        if (granted === metadata.size)
+            return await readFile(absolutePath);
+        const handle = await open(absolutePath, "r");
+        try {
+            const buffer = Buffer.allocUnsafe(granted);
+            const { bytesRead } = await handle.read(buffer, 0, granted, 0);
+            return buffer.subarray(0, bytesRead);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async access(absolutePath) {
+        this.assertReadablePath(absolutePath);
+        this.reserveFile(absolutePath);
+        await access(absolutePath);
+    }
+    limitToolResult(result) {
+        if (!result || typeof result !== "object" || !Array.isArray(result.content)) {
+            return result;
+        }
+        const content = result.content.map((item) => {
+            if (!item || item.type !== "text" || typeof item.text !== "string") {
+                this.report("read budget truncated: non-text tool result omitted");
+                return {
+                    type: "text",
+                    text: "[read budget reached: non-text result omitted]",
+                };
+            }
+            const granted = this.reserveBytes(Buffer.byteLength(item.text));
+            return {
+                ...item,
+                text: truncateUtf8(item.text, granted),
+            };
+        });
+        return { ...result, content };
+    }
+}
+function truncateUtf8(text, maxBytes) {
+    if (Buffer.byteLength(text) <= maxBytes)
+        return text;
+    const marker = "\n[read result truncated by node budget]";
+    const markerBytes = Buffer.byteLength(marker);
+    if (maxBytes <= markerBytes)
+        return truncateUtf8Prefix(marker, maxBytes);
+    const contentBudget = maxBytes - markerBytes;
+    return `${truncateUtf8Prefix(text, contentBudget)}${marker}`;
+}
+function truncateUtf8Prefix(text, maxBytes) {
+    let result = "";
+    let bytes = 0;
+    for (const codePoint of text) {
+        const size = Buffer.byteLength(codePoint);
+        if (bytes + size > maxBytes)
+            break;
+        result += codePoint;
+        bytes += size;
+    }
+    return result;
+}
+function wrapTool(definition, guard, consumeResult) {
+    return {
+        ...definition,
+        async execute(...args) {
+            try {
+                if (!guard.beforeToolOperation())
+                    return guard.operationLimitGuidance();
+                const result = await definition.execute(...args);
+                return consumeResult ? guard.limitToolResult(result) : result;
+            }
+            catch (error) {
+                if (error instanceof PiReadBudgetSoftLimitError) {
+                    return guard.operationLimitGuidance();
+                }
+                if (error instanceof PiReadAccessDeniedError) {
+                    return guard.readAccessGuidance();
+                }
+                throw error;
+            }
+        },
+    };
+}
+/**
+ * Override Pi's built-in read-only tools with SDK definitions that meter the
+ * content before it reaches the model. The read tool caps filesystem bytes at
+ * the operation boundary; grep/find/ls have their returned payload clipped
+ * before the agent receives it. This is SDK-only by design: the CLI backend
+ * cannot inject same-name built-in overrides safely.
+ */
+export async function createPiReadBudgetCustomTools(input) {
+    const sdk = (await import("@earendil-works/pi-coding-agent"));
+    const createReadToolDefinition = sdk.createReadToolDefinition;
+    const createGrepToolDefinition = sdk.createGrepToolDefinition;
+    const createFindToolDefinition = sdk.createFindToolDefinition;
+    const createLsToolDefinition = sdk.createLsToolDefinition;
+    if (typeof createReadToolDefinition !== "function" ||
+        typeof createGrepToolDefinition !== "function" ||
+        typeof createFindToolDefinition !== "function" ||
+        typeof createLsToolDefinition !== "function") {
+        throw new Error("pi read budget policy unavailable: SDK read/grep/find/ls tool factories missing");
+    }
+    const guard = new PiReadBudgetGuard(input.budget, input.readAccess);
+    const read = wrapTool(createReadToolDefinition(input.repoRoot, {
+        operations: {
+            readFile: (absolutePath) => guard.readFile(absolutePath),
+            access: (absolutePath) => guard.access(absolutePath),
+        },
+    }), guard, false);
+    const grep = wrapTool(createGrepToolDefinition(input.repoRoot), guard, true);
+    const find = wrapTool(createFindToolDefinition(input.repoRoot), guard, true);
+    const ls = wrapTool(createLsToolDefinition(input.repoRoot), guard, true);
+    if (read.name !== "read" ||
+        grep.name !== "grep" ||
+        find.name !== "find" ||
+        ls.name !== "ls") {
+        throw new Error("pi read budget policy unavailable: SDK tool name mismatch");
+    }
+    return { customTools: [read, grep, find, ls], issues: () => guard.issues() };
+}