@tea-agent/loop-agent 0.42.0-next.9 → 0.42.1

package/dist/executors/pi-executor.js

@@ -1,3 +1,4 @@
+import { collectFrontendUsage, createFrontendReadObservation, observeFrontendAttempt } from "../workflows/dag/frontend-session-budget.js";
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
@@ -453,6 +454,9 @@ export function extractPiEventStopReason(event) {
     return undefined;
 }
 export class PiJsonlStreamCollector {
+    frontendReads = createFrontendReadObservation();
+    frontendUsageEvents = [];
+    frontendObservation() { return { readObservation: this.frontendReads.snapshot(), usageObservation: collectFrontendUsage(this.frontendUsageEvents) }; }
     lineBuffer = "";
     discardUntilNewline = false;
     assistantText = "";
@@ -518,6 +522,13 @@ export class PiJsonlStreamCollector {
         }
     }
     consumeEvent(event) {
+        try {
+            this.frontendReads.observe(event);
+            const message = isRecord(event.message) ? event.message : undefined;
+            if (event.usage || message?.usage || event.tokenUsage)
+                this.frontendUsageEvents.push({ responseId: event.responseId, messageId: event.messageId, usage: event.usage, tokenUsage: event.tokenUsage, message: message ? { role: message.role, id: message.id, responseId: message.responseId, usage: message.usage } : undefined });
+        }
+        catch { /* observation only */ }
         const stopReason = extractPiEventStopReason(event);
         if (stopReason === "length" || !this.stopReason) {
             this.stopReason = stopReason ?? this.stopReason;
@@ -696,6 +707,8 @@ function shouldFallbackSdkToCli(sdkResult, validationIssues, options) {
         return true;
     if (!sdkResult.ok &&
         (sdkResult.failureCategory === "auth" ||
+            sdkResult.failureCategory === "output-limit" ||
+            sdkResult.failureCategory === "cancelled" ||
             sdkResult.failureCategory === "timeout" ||
             sdkResult.failureCategory === "termination-unconfirmed")) {
         return false;
@@ -730,6 +743,8 @@ function writerPolicyFailureResult(options, message, extras) {
 export async function executePiStep(options) {
     const backendMode = resolvePiBackend();
     const writerRequiresSdk = options.writerToolPolicy?.requireSdk === true;
+    if (options.reserveProviderRequest && backendMode === "cli-only")
+        return { ...writerPolicyFailureResult(options, "FRONTEND_PROVIDER_BUDGET_UNSUPPORTED: actual request admission requires SDK", { sdkAttempted: false }), failureCategory: "budget_breach" };
     if (backendMode === "cli-only") {
         if (writerRequiresSdk) {
             return writerPolicyFailureResult(options, "pi writer tool policy requires SDK backend; CODE_AGENT_PI_BACKEND=cli-only is fail-closed for writers", { sdkAttempted: false, backend: "cli" });
@@ -745,6 +760,8 @@ export async function executePiStep(options) {
     const { checkPiSdkAvailability, executeSingleSdkAttempt, getActivePiSdkReuseScope, } = await import("./pi-sdk-executor.js");
     const sdkCheck = await checkPiSdkAvailability(options.repoRoot);
     if (!sdkCheck.ok) {
+        if (options.reserveProviderRequest)
+            return { ...writerPolicyFailureResult(options, `FRONTEND_PROVIDER_BUDGET_UNSUPPORTED: ${sdkCheck.detail}`, { sdkAttempted: false }), failureCategory: "budget_breach" };
         if (writerRequiresSdk) {
             return writerPolicyFailureResult(options, `pi writer tool policy requires SDK; ${sdkCheck.detail}`, { sdkAttempted: false });
         }
@@ -773,7 +790,7 @@ export async function executePiStep(options) {
             reuseRuntimeActive,
         });
     }
-    if (!shouldFallbackSdkToCli(sdkResult, validationIssues, options)) {
+    if (options.reserveProviderRequest || !shouldFallbackSdkToCli(sdkResult, validationIssues, options)) {
         const failureCategory = validationIssues.length > 0
             ? "invalid-output"
             : sdkResult.failureCategory;
@@ -798,6 +815,9 @@ export async function executePiStep(options) {
     return { ...cliResult, reuseRuntimeActive };
 }
 async function executeSingleCliAttempt(options, modelConfig, promptFilePath) {
+    return observeFrontendAttempt({ backend: "cli", model: [modelConfig.provider, modelConfig.model].filter(Boolean).join("/"), observer: options.onAttemptObservation }, () => executeSingleCliAttemptInternal(options, modelConfig, promptFilePath));
+}
+async function executeSingleCliAttemptInternal(options, modelConfig, promptFilePath) {
     const modelDisplay = modelConfig.provider && modelConfig.model
         ? `${modelConfig.provider}/${modelConfig.model}`
         : (modelConfig.model ?? "default");
@@ -900,6 +920,7 @@ async function executeSingleCliAttempt(options, modelConfig, promptFilePath) {
                 });
             resolve({
                 assistantText: collected.assistantText,
+                ...stdoutCollector.frontendObservation(),
                 command: ["pi", ...recordedPiArgs],
                 durationMs,
                 exitCode: code,

package/dist/executors/pi-extension-resolver.js

@@ -62,9 +62,21 @@ function readSettingsPackages(settingsPath) {
         return undefined;
     }
 }
-/** Strip an `npm:` prefix from a settings package spec, e.g. `npm:pi-lens`. */
+/**
+ * Strip an `npm:` prefix and a trailing `@<version>`/`@<dist-tag>` suffix
+ * from a settings package spec, e.g. `npm:pi-lens@3.8.72` → `pi-lens`,
+ * `npm:@scope/pkg@1.0.0` → `@scope/pkg`. The leading `@` of a scoped
+ * package name is preserved (the version separator is the LAST `@` at a
+ * positive index). Mirrors the console-side spec parsing semantics so a
+ * version-pinned install (e.g. via `pi install npm:pi-lens@3.8.72`) resolves
+ * identically in both surfaces.
+ */
 export function packageNameFromSpec(spec) {
-    return spec.startsWith("npm:") ? spec.slice(4) : spec;
+    const base = spec.startsWith("npm:") ? spec.slice(4) : spec;
+    const at = base.lastIndexOf("@");
+    if (at > 0)
+        return base.slice(0, at);
+    return base;
 }
 function loadPackageInventories(repoRoot) {
     const agentDir = getPiAgentDir();

package/dist/executors/pi-sdk-executor.js

@@ -1,3 +1,5 @@
+import { collectFrontendUsage, createFrontendReadObservation, observeFrontendAttempt } from "../workflows/dag/frontend-session-budget.js";
+import { frontendModelCapabilities, measureFrontendRequestEnvelope } from "../shared/frontend-execution-policy.js";
 import { appendFile, mkdir } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -7,6 +9,42 @@ import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DE
 import { serializeSessionEvent } from "./pi-event-serializer.js";
 import { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY, } from "../shared/pi-retry-settings.js";
 import { createCompactionController, createContextPressureExtension, createSiftBridgeState, inMemoryCompactionSettings, isDagSiftEnabled, parseCompactionPolicy, parseSiftBridgeConfig, SIFT_RETRIEVE_TOOL_NAME, } from "../shared/pi-context-pressure/index.js";
+/** Maximum number of same-session continuations after provider output truncation. */
+export const PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX = 3;
+export const PI_SDK_OUTPUT_LIMIT_CONTINUE_PROMPT = "继续。上一轮因输出长度上限（stopReason=length）截断；当前会话、工具与已完成工作仍保留。只完成尚未完成的部分，不重做已成功的写入或事实提交。";
+/** Wrap the actual stream seam: tool turns, retries and compaction all await it. */
+export async function installPiProviderRequestBudget(session, reserve, onFailure, capacity) {
+    const agent = session.agent;
+    const original = agent?.streamFunction;
+    if (!agent || typeof original !== "function")
+        throw Error("FRONTEND_PROVIDER_BUDGET_UNSUPPORTED: SDK actual request stream unavailable");
+    const { createAssistantMessageEventStream } = await import("@earendil-works/pi-ai");
+    agent.streamFunction = async (...args) => {
+        try {
+            if (args[2]?.signal?.aborted)
+                throw Error("FRONTEND_PROVIDER_REQUEST_ABORTED");
+            if (capacity) {
+                const measurement = measureFrontendRequestEnvelope(args[1], args[0], capacity.policy);
+                capacity.observe(measurement);
+                if (measurement.exceedsEstimate)
+                    throw Error(`FRONTEND_CONTEXT_ESTIMATE_EXCEEDED: estimated=${measurement.estimatedTokens} available=${measurement.availableInputTokens}; estimator=${measurement.estimatorVersion}; registry capability is not a measured gateway limit`);
+            }
+            await reserve();
+            if (args[2]?.signal?.aborted)
+                throw Error("FRONTEND_PROVIDER_REQUEST_ABORTED");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            onFailure(message);
+            const stream = createAssistantMessageEventStream();
+            const model = args[0] ?? {};
+            stream.push({ type: "error", reason: "error", error: { role: "assistant", content: [], api: model.api ?? "unknown", provider: model.provider ?? "unknown", model: model.id ?? "unknown", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } }, stopReason: "error", errorMessage: message, timestamp: Date.now() } });
+            stream.end();
+            return stream;
+        }
+        return original.apply(agent, args);
+    };
+}
 /** Same-session recovery after a transport stall. Exactly one continue per SDK attempt. */
 export const PI_SDK_STALL_CONTINUE_MAX = 1;
 /**
@@ -544,6 +582,9 @@ function aggregateSdkTokenUsage(samples) {
  * same session; that is in-attempt recovery, not cross-step session reuse.
  */
 export async function executeSingleSdkAttempt(options) {
+    return observeFrontendAttempt({ backend: "sdk", model: [options.modelConfig.provider, options.modelConfig.model].filter(Boolean).join("/"), observer: options.onAttemptObservation }, () => executeSingleSdkAttemptInternal(options));
+}
+async function executeSingleSdkAttemptInternal(options) {
     const modelConfig = options.modelConfig;
     const modelDisplay = modelConfig.provider && modelConfig.model
         ? `${modelConfig.provider}/${modelConfig.model}`
@@ -568,9 +609,16 @@ export async function executeSingleSdkAttempt(options) {
     let timedOut = false;
     let terminationConfirmed = true;
     let stderr = "";
+    let providerBudgetFailure;
+    let capabilitiesObservation = frontendModelCapabilities(undefined);
+    const requestEnvelopeObservation = { peakBytes: 0, peakEstimatedTokens: 0, estimatorVersion: "utf8-bytes-div3-v1-estimate" };
     const stdoutPreview = new BoundedTextPreview("stdout");
     const stdoutCollector = createPiJsonlStreamCollector();
+    let turnCollector = createPiJsonlStreamCollector();
+    let committedTerminalObserved = false;
     const usageSamples = [];
+    const observationEvents = [];
+    const readObservation = createFrontendReadObservation();
     let observedTurns = 0;
     let contextBudgetExhausted = false;
     let contextBudgetDetail = "";
@@ -579,6 +627,9 @@ export async function executeSingleSdkAttempt(options) {
     // length-stopped thinking-only attempt with no persisted write tool calls is
     // still distinguishable from generic empty output.
     let stopReason;
+    let providerErrorMessage;
+    let promptIndex = 0;
+    let outputContinuesSent = 0;
     let thinkingObserved = false;
     let writeToolCallCount = 0;
     const observeWriterThinkingExhaustionEvidence = (event) => {
@@ -660,6 +711,13 @@ export async function executeSingleSdkAttempt(options) {
                 ? { additionalExtensionPaths: options.piExtensionPaths }
                 : {}),
         });
+        capabilitiesObservation = frontendModelCapabilities(session.agent?.state?.model);
+        if (options.reserveProviderRequest || options.frontendExecutionPolicy)
+            await installPiProviderRequestBudget(session, options.reserveProviderRequest ?? (async () => { }), message => { providerBudgetFailure = message; appendStderr(message); }, options.frontendExecutionPolicy ? { policy: options.frontendExecutionPolicy, observe: measurement => {
+                    capabilitiesObservation = measurement.capabilities;
+                    requestEnvelopeObservation.peakBytes = Math.max(requestEnvelopeObservation.peakBytes, measurement.bytes);
+                    requestEnvelopeObservation.peakEstimatedTokens = Math.max(requestEnvelopeObservation.peakEstimatedTokens, measurement.estimatedTokens);
+                } } : undefined);
         let resolveStall;
         let resolveSettlement;
         let resolveContextBudget;
@@ -718,6 +776,8 @@ export async function executeSingleSdkAttempt(options) {
             resolveContextBudget?.("context-budget");
         };
         unsubscribe = session.subscribe((event) => {
+            if (event.type === "tool_execution_end" && event.isError !== true && typeof event.toolName === "string" && options.outputLimitRecovery?.terminalToolNames.includes(event.toolName) && isRecord(event.result) && isRecord(event.result.details) && event.result.details.ok === true)
+                committedTerminalObserved = true;
             if (event.type === "agent_settled" && !settled) {
                 settled = true;
                 resolveSettlement?.("settled");
@@ -737,9 +797,18 @@ export async function executeSingleSdkAttempt(options) {
                     // best-effort: activity must never change Pi result
                 }
             }
+            const observationMessage = isRecord(event.message) ? event.message : undefined;
+            if (typeof observationMessage?.errorMessage === "string")
+                providerErrorMessage = observationMessage.errorMessage;
+            try {
+                readObservation.observe(event);
+            }
+            catch { /* observation must not change execution */ }
+            if (!(typeof observationMessage?.errorMessage === "string" && observationMessage.errorMessage.startsWith("FRONTEND_PROVIDER_")) && (event.usage || observationMessage?.usage || event.tokenUsage))
+                observationEvents.push({ responseId: event.responseId, messageId: event.messageId, usage: event.usage, tokenUsage: event.tokenUsage, message: observationMessage ? { role: observationMessage.role, id: observationMessage.id, responseId: observationMessage.responseId, usage: observationMessage.usage } : undefined });
             const usageSample = extractSdkUsageSample(event);
             if (usageSample)
-                usageSamples.push(usageSample);
+                usageSamples.push({ ...usageSample, responseKey: usageSample.responseKey ?? `turn-${promptIndex}` });
             if (event.type === "turn_end")
                 observedTurns += 1;
             checkContextBudget();
@@ -753,6 +822,7 @@ export async function executeSingleSdkAttempt(options) {
             const line = serializeSessionEvent(event);
             stdoutPreview.append(`${line}\n`);
             stdoutCollector.append(`${line}\n`);
+            turnCollector.append(`${line}\n`);
             sessionEventAppender?.append(line, event);
         });
         const timeoutPromise = timeoutMs > 0
@@ -763,6 +833,9 @@ export async function executeSingleSdkAttempt(options) {
             })
             : null;
         const runTurn = async (userMessage) => {
+            promptIndex += 1;
+            stopReason = undefined;
+            turnCollector = createPiJsonlStreamCollector();
             const settlementPromise = resetSettlement();
             const stallPromise = resetStallPromise();
             const contextBudgetPromise = options.contextBudget
@@ -808,48 +881,61 @@ export async function executeSingleSdkAttempt(options) {
             : options.userMessage;
         let continuesSent = 0;
         let raced = await runTurn(promptMessage);
-        if (raced === "context-budget") {
-            appendStderr(contextBudgetDetail);
-            abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
-            await disposeSession();
-        }
-        else if (raced === "stall") {
-            abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
-            const withinAbsoluteTimeout = timeoutMs <= 0 || Date.now() - startedAt < timeoutMs;
-            const canContinue = abortConfirmed &&
-                writeToolCallCount === 0 &&
-                withinAbsoluteTimeout &&
-                continuesSent < PI_SDK_STALL_CONTINUE_MAX;
-            if (canContinue) {
-                // The aborted turn's stopReason must not leak onto a recovered continue.
-                stopReason = undefined;
-                continuesSent += 1;
-                persistRuntimeNote({
-                    type: "loop-agent-stall-continue",
-                    prompt: PI_SDK_STALL_CONTINUE_PROMPT,
-                    maxContinues: PI_SDK_STALL_CONTINUE_MAX,
-                });
-                raced = await runTurn(PI_SDK_STALL_CONTINUE_PROMPT);
-                if (raced !== "done" && raced !== "settled") {
-                    await failClosedAfterWait(raced === "stall" ? "stall" : "absolute-timeout", raced === "stall"
-                        ? "pi SDK stall continue did not recover; treating as timeout"
-                        : "pi SDK stall continue hit the absolute timeout", true);
+        while (true) {
+            if (raced === "context-budget") {
+                appendStderr(contextBudgetDetail);
+                abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+                await disposeSession();
+            }
+            else if (raced === "stall") {
+                abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+                const withinAbsoluteTimeout = timeoutMs <= 0 || Date.now() - startedAt < timeoutMs;
+                const canContinue = abortConfirmed &&
+                    writeToolCallCount === 0 &&
+                    withinAbsoluteTimeout &&
+                    continuesSent < PI_SDK_STALL_CONTINUE_MAX;
+                if (canContinue) {
+                    // The aborted turn's stopReason must not leak onto a recovered continue.
+                    stopReason = undefined;
+                    continuesSent += 1;
+                    persistRuntimeNote({
+                        type: "loop-agent-stall-continue",
+                        prompt: PI_SDK_STALL_CONTINUE_PROMPT,
+                        maxContinues: PI_SDK_STALL_CONTINUE_MAX,
+                    });
+                    raced = await runTurn(PI_SDK_STALL_CONTINUE_PROMPT);
+                    if (raced !== "done" && raced !== "settled") {
+                        await failClosedAfterWait(raced === "stall" ? "stall" : "absolute-timeout", raced === "stall"
+                            ? "pi SDK stall continue did not recover; treating as timeout"
+                            : "pi SDK stall continue hit the absolute timeout", true);
+                    }
+                }
+                else {
+                    await failClosedAfterWait("stall", !abortConfirmed
+                        ? undefined
+                        : writeToolCallCount > 0
+                            ? "pi SDK stall continue skipped because write tools already ran"
+                            : "pi SDK stall continue skipped because absolute timeout elapsed", false);
                 }
             }
-            else {
-                await failClosedAfterWait("stall", !abortConfirmed
-                    ? undefined
-                    : writeToolCallCount > 0
-                        ? "pi SDK stall continue skipped because write tools already ran"
-                        : "pi SDK stall continue skipped because absolute timeout elapsed", false);
+            else if (raced === "absolute-timeout") {
+                await failClosedAfterWait("absolute-timeout");
             }
-        }
-        else if (raced === "absolute-timeout") {
-            await failClosedAfterWait("absolute-timeout");
+            if (options.outputLimitRecovery && stopReason === "length" && !committedTerminalObserved && !stderr && outputContinuesSent < PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX && !timedOut) {
+                outputContinuesSent += 1;
+                const note = serializeSessionEvent({ type: "loop-agent-output-limit-continue", continue: outputContinuesSent, maxContinues: PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX, prompt: PI_SDK_OUTPUT_LIMIT_CONTINUE_PROMPT });
+                stdoutPreview.append(`${note}\n`);
+                stdoutCollector.append(`${note}\n`);
+                raced = await runTurn(PI_SDK_OUTPUT_LIMIT_CONTINUE_PROMPT);
+                continue;
+            }
+            break;
         }
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        if (options.reserveProviderRequest && message.startsWith("FRONTEND_PROVIDER_"))
+            providerBudgetFailure = message;
         appendStderr(message);
     }
     finally {
@@ -872,20 +958,29 @@ export async function executeSingleSdkAttempt(options) {
             }
         }
     }
+    if (providerErrorMessage && stopReason === "error" && !stderr)
+        appendStderr(providerErrorMessage);
+    if (options.outputLimitRecovery && stopReason === "length" && !committedTerminalObserved && outputContinuesSent >= PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX) {
+        const note = serializeSessionEvent({ type: "loop-agent-output-limit-exhausted", maxContinues: PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX });
+        stdoutPreview.append(`${note}\n`);
+    }
     const stdout = stdoutPreview.text();
     const durationMs = Date.now() - startedAt;
     const collected = stdoutCollector.finish();
     const fallbackParsed = collected.parsedEvents > 0
         ? undefined
         : extractAssistantTextFromPiJson(stdout);
+    const finalTurn = turnCollector.finish();
     const assistantText = collected.parsedEvents > 0
-        ? collected.assistantText
+        ? finalTurn.assistantText
         : (fallbackParsed?.assistantText ?? "");
     const parsedEvents = collected.parsedEvents > 0
         ? collected.parsedEvents
         : (fallbackParsed?.parsedEvents ?? 0);
     const tokensUsed = aggregateSdkTokenUsage(usageSamples);
-    const failureCategory = terminationConfirmed
+    const cancelled = stopReason === "aborted";
+    const outputLimitExhausted = Boolean(options.outputLimitRecovery && stopReason === "length" && !committedTerminalObserved && !timedOut && !stderr);
+    const failureCategory = !terminationConfirmed ? "termination-unconfirmed" : stopReason === "aborted" ? "cancelled" : outputLimitExhausted ? "output-limit" : providerBudgetFailure ? (providerBudgetFailure.includes("REQUEST_ABORTED") ? "interrupted" : providerBudgetFailure.startsWith("FRONTEND_CONTEXT_ESTIMATE_EXCEEDED") ? "context-budget-exhausted" : "budget_breach") : terminationConfirmed
         ? classifyPiFailure({
             assistantText,
             exitCode: timedOut ? 1 : stderr ? 1 : 0,
@@ -900,12 +995,14 @@ export async function executeSingleSdkAttempt(options) {
         backend: "sdk",
         command: ["pi-sdk", ...piSdkArgs],
         durationMs,
-        exitCode: timedOut || stderr ? 1 : 0,
+        exitCode: timedOut || stderr || outputLimitExhausted || cancelled ? 1 : 0,
         failureCategory,
         modelDisplay,
         ok: terminationConfirmed &&
             !timedOut &&
             !stderr &&
+            !outputLimitExhausted &&
+            !cancelled &&
             assistantText.length > 0 &&
             !collected.outputTooLarge,
         parsedEvents,
@@ -915,6 +1012,10 @@ export async function executeSingleSdkAttempt(options) {
         outputTooLarge: collected.outputTooLarge,
         timedOut,
         tokensUsed,
+        usageObservation: collectFrontendUsage(observationEvents),
+        readObservation: readObservation.snapshot(),
+        capabilitiesObservation,
+        ...(options.frontendExecutionPolicy ? { requestEnvelopeObservation } : {}),
         subagentStats: collected.subagentStats,
         // Writer-thinking-exhausted diagnosis evidence (AC-002). Carried through
         // the object spread in executePiStep so executeDagPiNode can read them