@tea-agent/loop-agent 0.39.0-next.3 → 0.39.0-next.30

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

@@ -1,8 +1,16 @@
 import { appendFile, mkdir } from "node:fs/promises";
 import path from "node:path";
-import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_ABORT_GRACE_MS, DEFAULT_STALL_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, extractAssistantTextFromPiJson, } from "./pi-executor.js";
+import { computeExtensionToolAllowlistExtras } from "./pi-extension-resolver.js";
+import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_ABORT_GRACE_MS, DEFAULT_STALL_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, extractPiEventStopReason, extractAssistantTextFromPiJson, } from "./pi-executor.js";
 import { serializeSessionEvent } from "./pi-event-serializer.js";
 import { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY, } from "../shared/pi-retry-settings.js";
+/** Same-session recovery after a transport stall. Exactly one continue per SDK attempt. */
+export const PI_SDK_STALL_CONTINUE_MAX = 1;
+/**
+ * Fixed follow-up sent after aborting a stalled prompt.
+ * Kept short so the model can resume without repeating the original task payload.
+ */
+export const PI_SDK_STALL_CONTINUE_PROMPT = "继续。上一轮因长时间无 provider 活动已被中止；请从中断处接着完成，不要重复已完成的步骤。若此前没有有效输出，请重新执行原任务。";
 let sdkSessionFactoryOverride;
 let sdkImportOverrideForTests;
 let sdkModuleOverrideForTests;
@@ -44,15 +52,15 @@ export async function resetPiSdkReuseScopeForTests() {
 export function setPiSdkSessionFactoryForTests(factory) {
     sdkSessionFactoryOverride = factory;
 }
-/** Test hook: simulate SDK import success/failure without relying on optionalDependency install state. */
+/** Test hook: simulate SDK import success/failure without relying on installed SDK state. */
 export function setPiSdkImportOverrideForTests(fn) {
     sdkImportOverrideForTests = fn;
 }
-/** Test hook: inject a mock Pi SDK module to exercise resolveSdkSessionFactory without optionalDependency. */
+/** Test hook: inject a mock Pi SDK module to exercise resolveSdkSessionFactory without loading the real SDK. */
 export function setPiSdkModuleOverrideForTests(fn) {
     sdkModuleOverrideForTests = fn;
 }
-/** Check whether the Pi SDK optional dependency satisfies the 0.80.10 runtime contract. */
+/** Check whether the Pi SDK runtime dependency satisfies the 0.83.0 runtime contract. */
 export async function checkPiSdkAvailability(_repoRoot) {
     if (sdkSessionFactoryOverride) {
         return { ok: true, detail: "pi SDK session factory override active" };
@@ -68,10 +76,10 @@ export async function checkPiSdkAvailability(_repoRoot) {
             typeof ModelRuntime?.create !== "function") {
             return {
                 ok: false,
-                detail: "pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.80.10 contract)",
+                detail: "pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.83.0 contract)",
             };
         }
-        return { ok: true, detail: "pi SDK 0.80.10 contract available" };
+        return { ok: true, detail: "pi SDK 0.83.0 contract available" };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -222,6 +230,9 @@ async function createSdkSession(sdk, input, shared) {
         noContextFiles: true,
         noSkills: true,
         noExtensions: true,
+        ...(input.additionalExtensionPaths && input.additionalExtensionPaths.length > 0
+            ? { additionalExtensionPaths: input.additionalExtensionPaths }
+            : {}),
         ...(settingsManager ? { settingsManager } : {}),
         appendSystemPromptOverride: (base) => [
             ...base,
@@ -229,6 +240,19 @@ async function createSdkSession(sdk, input, shared) {
         ],
     });
     await loader.reload();
+    // Discover extension-registered tool names BEFORE session creation (plan
+    // 2026-08-21 D5): verified against the real SDK — passing extension tool
+    // names in createAgentSession `tools` activates them, while a post-create
+    // setActiveToolsByName pin leaves the active set unchanged. Merge filtered
+    // extras into the create-time allowlist; protected builtins, the deny
+    // surface, and write-capable extension tools never join.
+    const extensionToolExtras = [];
+    if (input.additionalExtensionPaths &&
+        input.additionalExtensionPaths.length > 0) {
+        const registered = collectLoaderExtensionToolNames(loader);
+        extensionToolExtras.push(...computeExtensionToolAllowlistExtras(registered.map((name) => ({ name })), input.toolNames));
+    }
+    const sessionToolNames = [...input.toolNames, ...extensionToolExtras];
     if (input.requireWriterCustomTools) {
         if (!Array.isArray(input.customTools) || input.customTools.length === 0) {
             throw new Error("pi writer tool policy missing customTools; refusing to create uncontrolled writer session");
@@ -238,7 +262,7 @@ async function createSdkSession(sdk, input, shared) {
         cwd: input.cwd,
         sessionManager: SessionManager.inMemory(input.cwd),
         resourceLoader: loader,
-        tools: input.toolNames,
+        tools: sessionToolNames,
         modelRuntime,
         ...(settingsManager ? { settingsManager } : {}),
         ...(model ? { model } : {}),
@@ -247,6 +271,22 @@ async function createSdkSession(sdk, input, shared) {
             ? { customTools: input.customTools }
             : {}),
     });
+    if (extensionToolExtras.length > 0) {
+        // Fail closed when merged extension tools did not activate: a silent
+        // pin failure must never let the node run without its declared tools.
+        const activeTools = created.session.agent?.state?.tools;
+        if (!Array.isArray(activeTools)) {
+            throw new Error("pi SDK session does not expose agent.state.tools; refusing unverifiable extension-tool activation");
+        }
+        const activeNames = new Set(activeTools
+            .map((tool) => typeof tool?.name === "string" ? tool.name : undefined)
+            .filter((name) => Boolean(name)));
+        for (const extensionToolName of extensionToolExtras) {
+            if (!activeNames.has(extensionToolName)) {
+                throw new Error(`pi SDK extension-tool activation mismatch for ${extensionToolName}: tool did not activate at session creation`);
+            }
+        }
+    }
     const customToolNames = (input.customTools ?? [])
         .map((tool) => isRecord(tool) && typeof tool.name === "string" ? tool.name : undefined)
         .filter((name) => Boolean(name));
@@ -259,7 +299,7 @@ async function createSdkSession(sdk, input, shared) {
             .map((tool) => typeof tool?.name === "string" ? tool.name : undefined)
             .filter((name) => Boolean(name)));
         for (const customToolName of customToolNames) {
-            const expectedActive = input.toolNames.includes(customToolName);
+            const expectedActive = sessionToolNames.includes(customToolName);
             if (activeNames.has(customToolName) !== expectedActive) {
                 throw new Error(`pi SDK custom-tool activation mismatch for ${customToolName}: expectedActive=${expectedActive}`);
             }
@@ -267,6 +307,47 @@ async function createSdkSession(sdk, input, shared) {
     }
     return created.session;
 }
+/**
+ * Collect tool names registered by loader-resolved extensions. The SDK exposes
+ * each extension's `tools` as a Record (name → definition) or Map; both shapes
+ * are handled. Missing getExtensions (older SDK) yields no extras — the node
+ * then runs with the baseline allowlist only.
+ */
+function collectLoaderExtensionToolNames(loader) {
+    const getExtensions = loader?.getExtensions;
+    if (typeof getExtensions !== "function")
+        return [];
+    let parsed;
+    try {
+        parsed = getExtensions.call(loader);
+    }
+    catch {
+        return [];
+    }
+    if (!parsed || typeof parsed !== "object")
+        return [];
+    const extensions = parsed.extensions;
+    if (!Array.isArray(extensions))
+        return [];
+    const names = [];
+    for (const extension of extensions) {
+        if (!extension || typeof extension !== "object")
+            continue;
+        const tools = extension.tools;
+        if (tools instanceof Map) {
+            for (const key of tools.keys()) {
+                if (typeof key === "string")
+                    names.push(key);
+            }
+        }
+        else if (tools && typeof tools === "object") {
+            for (const key of Object.keys(tools)) {
+                names.push(key);
+            }
+        }
+    }
+    return names;
+}
 /**
  * Throttle high-noise Pi SDK events from session-events.jsonl.
  * Always keeps tool lifecycle, turn/agent end, assistant messages, and errors.
@@ -404,25 +485,6 @@ function extractSdkUsageSample(event) {
     const responseKey = responseKeyCandidates.find((value) => typeof value === "string" && value.length > 0);
     return responseKey ? { responseKey, tokens } : { tokens };
 }
-/** Extract a non-empty stop reason from a terminal SDK event.
- * Probes multiple field shapes across SDK versions so a missing field fails
- * open (undefined) rather than misclassifying an attempt. */
-function readStopReason(event) {
-    const message = isRecord(event.message) ? event.message : undefined;
-    const candidates = [
-        message?.stop_reason,
-        message?.stopReason,
-        event.stopReason,
-        event.stop_reason,
-    ];
-    for (const candidate of candidates) {
-        if (typeof candidate === "string" &&
-            candidate.trim().length > 0) {
-            return candidate.trim();
-        }
-    }
-    return undefined;
-}
 function aggregateSdkTokenUsage(samples) {
     const identified = new Map();
     let anonymousMaximum = 0;
@@ -444,6 +506,8 @@ function aggregateSdkTokenUsage(samples) {
  * When reuseScope is active, only shared auth/model resources are reused; each attempt still
  * creates and disposes its own session and resource loader. Session reuse across steps is
  * deferred until a proven reset/isolation strategy exists.
+ * A transport stall may abort the current prompt and send one continue on the
+ * same session; that is in-attempt recovery, not cross-step session reuse.
  */
 export async function executeSingleSdkAttempt(options) {
     const modelConfig = options.modelConfig;
@@ -494,7 +558,7 @@ export async function executeSingleSdkAttempt(options) {
             type === "message_end" ||
             type === "agent_end" ||
             type === "agent_settled") {
-            const candidate = readStopReason(event);
+            const candidate = extractPiEventStopReason(event);
             if (candidate)
                 stopReason = candidate;
         }
@@ -555,20 +619,37 @@ export async function executeSingleSdkAttempt(options) {
                 ? { customTools: writerCustomTools }
                 : {}),
             ...(requireWriterCustomTools ? { requireWriterCustomTools: true } : {}),
+            ...(options.piExtensionPaths && options.piExtensionPaths.length > 0
+                ? { additionalExtensionPaths: options.piExtensionPaths }
+                : {}),
         });
         let resolveStall;
         let resolveSettlement;
         let settled = false;
-        const settlementPromise = new Promise((resolve) => {
-            resolveSettlement = resolve;
-        });
-        const stallPromise = stallTimeoutMs > 0
-            ? new Promise((resolve) => {
+        let abortConfirmed = true;
+        const persistRuntimeNote = (event) => {
+            const line = serializeSessionEvent(event);
+            stdoutPreview.append(`${line}\n`);
+            stdoutCollector.append(`${line}\n`);
+            sessionEventAppender?.append(line, event);
+        };
+        const resetSettlement = () => {
+            settled = false;
+            return new Promise((resolve) => {
+                resolveSettlement = resolve;
+            });
+        };
+        const resetStallPromise = () => {
+            if (stallTimeoutMs <= 0) {
+                resolveStall = undefined;
+                return null;
+            }
+            return new Promise((resolve) => {
                 resolveStall = resolve;
-            })
-            : null;
+            });
+        };
         const armStallWatchdog = () => {
-            if (!stallPromise || !resolveStall)
+            if (stallTimeoutMs <= 0 || !resolveStall)
                 return;
             if (stallHandle)
                 clearTimeout(stallHandle);
@@ -609,17 +690,6 @@ export async function executeSingleSdkAttempt(options) {
             stdoutCollector.append(`${line}\n`);
             sessionEventAppender?.append(line, event);
         });
-        const filePrefix = options.attachedFiles
-            .map((file) => `@${file}`)
-            .join(" ");
-        const promptMessage = filePrefix
-            ? `${filePrefix}\n${options.userMessage}`
-            : options.userMessage;
-        const promptPromise = session.prompt(promptMessage);
-        // A settlement event is permitted to win the race while prompt() remains
-        // pending. Observe a later rejection so it never becomes unhandled.
-        void promptPromise.catch(() => { });
-        armStallWatchdog();
         const timeoutPromise = timeoutMs > 0
             ? new Promise((resolve) => {
                 timeoutHandle = setTimeout(() => {
@@ -627,21 +697,79 @@ export async function executeSingleSdkAttempt(options) {
                 }, timeoutMs);
             })
             : null;
-        const raced = await Promise.race([
-            promptPromise.then(() => "done"),
-            settlementPromise,
-            ...(timeoutPromise ? [timeoutPromise] : []),
-            ...(stallPromise ? [stallPromise] : []),
-        ]);
-        if (raced !== "done" && raced !== "settled") {
-            timedOut = true;
-            appendStderr(raced === "stall"
-                ? `pi SDK step stalled after ${stallTimeoutMs}ms with no provider activity`
-                : `pi SDK step timed out after ${timeoutMs}ms`);
-            const abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+        const runTurn = async (userMessage) => {
+            const settlementPromise = resetSettlement();
+            const stallPromise = resetStallPromise();
+            const promptPromise = session.prompt(userMessage);
+            // A settlement event is permitted to win the race while prompt() remains
+            // pending. Observe a later rejection so it never becomes unhandled.
+            void promptPromise.catch(() => { });
+            armStallWatchdog();
+            return Promise.race([
+                promptPromise.then(() => "done"),
+                settlementPromise,
+                ...(timeoutPromise ? [timeoutPromise] : []),
+                ...(stallPromise ? [stallPromise] : []),
+            ]);
+        };
+        const disposeSession = async () => {
             disposeAttempted = true;
             const disposeConfirmed = await runSessionActionWithGrace("dispose", () => session.dispose());
             terminationConfirmed = abortConfirmed && disposeConfirmed;
+        };
+        const failClosedAfterWait = async (reason, extraStderr, abortFirst = true) => {
+            timedOut = true;
+            appendStderr(reason === "stall"
+                ? `pi SDK step stalled after ${stallTimeoutMs}ms with no provider activity`
+                : `pi SDK step timed out after ${timeoutMs}ms`);
+            if (extraStderr)
+                appendStderr(extraStderr);
+            if (abortFirst) {
+                abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+            }
+            await disposeSession();
+        };
+        const filePrefix = options.attachedFiles
+            .map((file) => `@${file}`)
+            .join(" ");
+        const promptMessage = filePrefix
+            ? `${filePrefix}\n${options.userMessage}`
+            : options.userMessage;
+        let continuesSent = 0;
+        let raced = await runTurn(promptMessage);
+        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 if (raced === "absolute-timeout") {
+            await failClosedAfterWait("absolute-timeout");
         }
     }
     catch (error) {