oira666_pi-subagent 0.2.8 → 0.2.10

package/index.ts

@@ -372,6 +372,8 @@ function hasCliInitialPrompt(argv: string[]): boolean {
 const RESUME_PROVIDER = "pi-subagent-resume";
 const RESUME_MODEL_ID = "synthetic-tool-call";
 const RESUME_STATE_KEY = "__piSubagentResumeState";
+const SUBAGENT_FALLBACK_MODEL_ENV = "PI_SUBAGENT_FALLBACK_MODEL";
+const RESUME_INTERACTIVE_DELAY_MS = 250;
 
 type SyntheticResumeState = {
   plan: ResumableSubagentCall | null;
@@ -449,9 +451,18 @@ function findLastNonResumeModel(ctx: any): any | undefined {
   return undefined;
 }
 
+function getEnvFallbackModel(ctx: any): any | undefined {
+  const raw = process.env[SUBAGENT_FALLBACK_MODEL_ENV];
+  if (!raw || !raw.includes("/")) return undefined;
+  const [provider, ...idParts] = raw.split("/");
+  const id = idParts.join("/");
+  if (!provider || !id) return undefined;
+  return ctx.modelRegistry?.find?.(provider, id);
+}
+
 function getRestorableModel(ctx: any): any | undefined {
   if (ctx.model?.provider && ctx.model.provider !== RESUME_PROVIDER) return ctx.model;
-  return findLastNonResumeModel(ctx);
+  return findLastNonResumeModel(ctx) ?? getEnvFallbackModel(ctx);
 }
 
 // ---------------------------------------------------------------------------
@@ -460,6 +471,22 @@ function getRestorableModel(ctx: any): any | undefined {
 
 export default function (pi: ExtensionAPI) {
   let resumeModelRegistry: any | undefined;
+  let lastRestorableModel: any | undefined;
+
+  async function streamWithRealModelFallback(context: any, options: any, fallback: any) {
+    if (!fallback) return null;
+    const auth = resumeModelRegistry
+      ? await resumeModelRegistry.getApiKeyAndHeaders(fallback)
+      : { ok: true, apiKey: undefined, headers: undefined };
+    if (!auth.ok) {
+      throw new Error(auth.error);
+    }
+    return streamModelSimple(fallback, context, {
+      ...options,
+      apiKey: auth.apiKey,
+      headers: auth.headers,
+    });
+  }
 
   pi.registerFlag("subagent-max-depth", {
     description: "Maximum allowed subagent delegation depth (default: 3).",
@@ -512,37 +539,31 @@ export default function (pi: ExtensionAPI) {
       }
 
       if (phase === "final" && modelToRestoreAfterResume) {
-        const restore = modelToRestoreAfterResume;
-        const auth = resumeModelRegistry
-          ? await resumeModelRegistry.getApiKeyAndHeaders(restore)
-          : { ok: true, apiKey: undefined, headers: undefined };
-        if (!auth.ok) {
-          throw new Error(auth.error);
-        }
-        return streamModelSimple(restore, context, {
-          ...options,
-          apiKey: auth.apiKey,
-          headers: auth.headers,
-        });
+        const delegated = await streamWithRealModelFallback(context, options, modelToRestoreAfterResume);
+        if (delegated) return delegated;
       }
 
+      const fallback = await streamWithRealModelFallback(context, options, lastRestorableModel);
+      if (fallback) return fallback;
+
       if (!(plan && phase === "tool")) {
         state.plan = null;
         state.phase = "tool";
       }
       const message = {
         role: "assistant" as const,
-        content: [],
+        content: [{ type: "text" as const, text: "Subagent resume failed: synthetic resume provider was invoked without a valid resume plan." }],
         api: model.api,
         provider: model.provider,
         model: model.id,
         usage: emptyModelUsage(),
-        stopReason: "stop" as const,
+        stopReason: "error" as const,
+        errorMessage: "Subagent resume failed: synthetic resume provider was invoked without a valid resume plan.",
         timestamp: Date.now(),
       };
       queueMicrotask(() => {
         stream.push({ type: "start", partial: message });
-        stream.push({ type: "done", reason: "stop", message });
+        stream.push({ type: "error", reason: "error", error: message });
         stream.end(message);
       });
       return stream;
@@ -601,6 +622,10 @@ export default function (pi: ExtensionAPI) {
       // nested subagents that can no longer delegate. Those leaf processes
       // still need the real model to continue their own work.
       const restorableModel = getRestorableModel(ctx);
+      if (restorableModel) {
+        lastRestorableModel = restorableModel;
+        resumeModelRegistry = ctx.modelRegistry;
+      }
       if (ctx.model?.provider === RESUME_PROVIDER && restorableModel) {
         await pi.setModel(restorableModel);
       }
@@ -660,7 +685,20 @@ export default function (pi: ExtensionAPI) {
       if (hasCliInitialPrompt(process.argv)) {
         if (ctx.hasUI) ctx.ui.notify(`Resuming ${plan.tasks.length} subagents...`, "info");
       } else {
-        pi.sendUserMessage(`Resuming ${plan.tasks.length} subagents...`);
+        // Do not start the synthetic resume turn synchronously from
+        // session_start. In interactive mode Pi may still be rebuilding the
+        // resumed chat UI; if the tool starts before that finishes, later
+        // renderSessionContext() can clear the live pending tool component and
+        // all real-time tool updates disappear. A short macrotask delay lets
+        // the normal "Resumed session" render settle first.
+        setTimeout(() => {
+          try {
+            pi.sendUserMessage(`Resuming ${plan.tasks.length} subagents...`);
+          } catch (err) {
+            console.error("[pi-subagent] Failed to start deferred resume turn:", err);
+            void restoreModelAfterResumeFailure(ctx);
+          }
+        }, RESUME_INTERACTIVE_DELAY_MS);
       }
     } catch (err) {
       console.error("[pi-subagent] Error in session_start:", err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-subagent",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "Subagent extension for Pi coding agent. Delegate tasks to specialized agents.",
   "type": "module",
   "main": "index.ts",