oira666_pi-subagent 0.2.7 → 0.2.9

package/index.ts

@@ -372,6 +372,7 @@ 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";
 
 type SyntheticResumeState = {
   plan: ResumableSubagentCall | null;
@@ -449,9 +450,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 +470,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 +538,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;
@@ -596,8 +616,21 @@ export default function (pi: ExtensionAPI) {
 
   // Auto-discover agents on session start
   pi.on("session_start", async (event, ctx) => {
-    if (!canDelegate) return;
     try {
+      // Always repair sessions left on the synthetic resume model, even in
+      // 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);
+      }
+
+      if (!canDelegate) return;
+
       const discovery = discoverAgents(ctx.cwd, "both");
       discoveredAgents = discovery.agents;
       currentSessionId = ctx.sessionManager.getSessionId?.() ?? "ephemeral";
@@ -613,11 +646,6 @@ export default function (pi: ExtensionAPI) {
         );
       }
 
-      const restorableModel = getRestorableModel(ctx);
-      if (ctx.model?.provider === RESUME_PROVIDER && restorableModel) {
-        await pi.setModel(restorableModel);
-      }
-
       const resumeDisabled = parseBooleanEnv(process.env[SUBAGENT_RESUME_DISABLE_ENV]) === true;
       if (resumeDisabled || (event.reason !== "resume" && event.reason !== "startup")) return;
 

package/package.json

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