@ferris1225/pi-subagents 2.0.0 → 2.0.2

package/README.md

@@ -88,9 +88,10 @@ index.
 - **Direct fallback with real thinking capabilities** — each agent has at most
   one selected model. An unavailable selection, rate limit, invalid key, quota,
   missing model, or provider failure hands directly to the current main model.
-  A child-only provider adapter forces request retries to zero, and the RPC
-  parent cancels Pi's outer turn retry before another call, without changing user
-  settings. Auto thinking clamps the agent preference to the
+  A child-only provider adapter forces inner request retries to zero; transient
+  stream drops still use Pi's outer turn retry, and only a settled model-level
+  failure hands off, without changing user settings. Auto thinking clamps the
+  agent preference to the
   effective model's real `thinkingLevelMap`; manual setup shows only levels that
   model supports.
 - **Resumes, retargets, and forks preserve context** — every run is session-backed.
@@ -277,7 +278,9 @@ sessions show the recovery paths again until the artifacts are removed.
 Stored at `~/.pi/agent/pi-subagents.json` (follows `PI_CODING_AGENT_DIR` when
 set). `/subagents-setup` has five top-level choices: enable agents, configure one
 agent's model/thinking, choose a vision model, runtime settings, or full setup.
-There is no backup pool or global thinking menu. Model pickers show only in-scope
+After one agent's model + thinking picks, the wizard returns to the agent picker
+so several agents can be configured in one pass; Esc at any step ends the pass
+and keeps every agent already configured. There is no backup pool or global thinking menu. Model pickers show only in-scope
 models with configured authentication and display their real supported thinking
 levels. Thinking defaults to **Auto**; manual overrides show only levels supported
 by that agent's effective model. `notifyOnReviewPass` and `maxResultLines` remain
@@ -329,12 +332,13 @@ available catalog is skipped. Any model-level runtime failure — rate limit,
 quota, invalid key/auth, missing model, provider error, or idle model stream —
 hands directly to current main, including stream errors that retain partial text.
 A child-only Pi extension wraps the selected provider's registered API stream
-with `maxRetries: 0`; if Pi schedules its separate outer turn retry, the RPC parent
-immediately sends `abort_retry` before another provider call. This uses supported
-extension/RPC surfaces in Node and standalone/Bun builds, never rewrites global or
-project settings, and does not alter descendant tool environments. Tool/test
-failures stay on the same model because they are task failures, not model
-availability failures. Only a truly
+with `maxRetries: 0` so a deterministic auth/quota miss fails fast. Transient
+stream drops such as xAI `terminated` still use Pi's outer turn retry — the
+parent does not `abort_retry` them — and only a settled model-level failure
+hands off to current main. This uses supported extension/RPC surfaces in Node
+and standalone/Bun builds, never rewrites global or project settings, and does
+not alter descendant tool environments. Tool/test failures stay on the same
+model because they are task failures, not model availability failures. Only a truly
 zero-activity process startup race can retry; an accepted prompt or any
 agent/turn/stream/tool activity forbids replay.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ferris1225/pi-subagents",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Controllable background sub-agent threads for pi: specialized roles, capability-aware thinking, direct main-model fallback, auto-fix chains, and Git worktree isolation.",
   "type": "module",
   "license": "MIT",

package/src/dispatch.ts

@@ -1483,7 +1483,8 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 								triggerTurn: completionTriggersTurn(result, runConfig.notifyOnReviewPass),
 							};
 							if (modelLevel) {
-								runCtx.ui.notify(`✗ ${result.agent} dispatch failed: model unavailable or broken — task handed to the main window`, "error");
+								const detail = result.errorMessage?.trim() || "model unavailable or broken";
+								runCtx.ui.notify(`✗ ${result.agent} dispatch failed: ${detail} — task handed to the main window`, "error");
 							} else if (dispatchFailed) {
 								runCtx.ui.notify(`✗ ${result.agent} dispatch failed: ${result.errorMessage ?? "dispatch crashed"}`, "error");
 							}

package/src/format.ts

@@ -155,11 +155,15 @@ export function formatCompletionBlock(
  * fresh (which would re-scan everything). */
 export function modelLevelTakeoverNote(result: SingleResult, opts?: { runId?: number }): string {
 	const retry = result.modelFallbackFrom ? ", and the current main model also failed" : "";
+	const detail = result.errorMessage?.trim();
+	const cause = detail
+		? `its model/provider call failed (${detail})`
+		: "its model was unavailable or failed (or the run stalled)";
 	const sessionPreserved = Boolean(result.sessionDir && result.sessionId) && opts?.runId !== undefined;
 	const recovery = sessionPreserved
 		? ` The sub-agent's earlier work in this run is preserved. Once a model is available again, call subagent_control with { action: "resume", id: ${opts!.runId} } to CONTINUE it in-context (it keeps the same run id and does not re-scan), or execute the task in the main window with your own tools.`
 		: ` Please execute this task in the main window with your own tools; do not re-dispatch it as a sub-agent.`;
-	return `The sub-agent could not complete this task: its model was unavailable or failed (or the run stalled)${retry}.${recovery}`;
+	return `The sub-agent could not complete this task: ${cause}${retry}.${recovery}`;
 }
 
 /** Resolve a run-id request to actual ids: an exact numeric match always wins

package/src/rpc-run.ts

@@ -813,12 +813,11 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 			result.rpcActivity = true;
 		}
 
-		// The child provider adapter disables request-level retries. Cancel Pi's
-		// separate outer turn retry the instant it is scheduled, before another
-		// same-model provider call can begin.
-		if (event.type === "auto_retry_start") {
-			void send({ type: "abort_retry" }).catch(() => undefined);
-		}
+		// Let Pi's outer turn retry run. Grok/xAI long streams commonly drop with
+		// a retryable `terminated` mid-turn; aborting that retry was misread as
+		// "model unavailable" and handed a still-working model back to the parent.
+		// After retries exhaust, dispatch still classifies a settled model-level
+		// failure and hands off.
 
 		// Child RPC mode exposes extension dialogs. Sub-agents are non-interactive:
 		// cancel blocking dialogs so an unrelated child extension cannot deadlock.

package/src/setup.ts

@@ -204,11 +204,46 @@ async function pickAgentToConfigure(
 	return promptSelectOne(
 		ctx,
 		"Configure which agent?",
-		"Type to filter • ↑/↓ • Enter selects • Esc cancels",
+		"Type to filter • ↑/↓ • Enter selects • Esc ends this pass",
 		enabledAgents.map((name) => ({ value: name, label: moduleLabel(name) })),
 	);
 }
 
+/** One agent: model, then thinking if the model exposes a choice. Esc at any
+ * step ends the caller's pass; earlier agents in that pass stay applied. */
+async function configureOneAgent(
+	ctx: ExtensionCommandContext,
+	config: SubagentsConfig,
+): Promise<
+	| {
+			name: string;
+			model: string;
+			strength: ThinkingLevel | typeof AUTO_THINKING;
+	  }
+	| undefined
+> {
+	const name = await pickAgentToConfigure(ctx, config.enabledAgents);
+	if (name === undefined) return undefined;
+	const modelChoice = await pickAgentModel(
+		ctx,
+		name,
+		config.agentModels[name],
+		"stops — earlier agent changes are kept",
+	);
+	if (modelChoice === undefined) return undefined;
+	const model = effectiveModelForChoice(ctx, modelChoice);
+	const strength = await pickAgentStrength(
+		ctx,
+		name,
+		model,
+		config.agentThinkingLevels[name],
+		actualAgentThinkingDefault(ctx, config, name),
+		"stops — earlier agent changes are kept",
+	);
+	if (strength === undefined) return undefined;
+	return { name, model: modelChoice, strength };
+}
+
 async function pickInjection(ctx: ExtensionCommandContext, current: boolean): Promise<boolean | undefined> {
 	const on = "On — inject the delegation directive (recommended)";
 	const off = "Off — rely on tool descriptions only";
@@ -379,28 +414,19 @@ async function runMenu(ctx: ExtensionCommandContext, configPath: string, config:
 		next.agentModels = keepAgentEntries(next.agentModels, enabled);
 		next.agentThinkingLevels = keepAgentEntries(next.agentThinkingLevels, enabled);
 	} else if (choice.startsWith("Configure")) {
-		const agentName = await pickAgentToConfigure(ctx, next.enabledAgents);
-		if (agentName === undefined) return notifyCancelled(ctx);
-		const modelChoice = await pickAgentModel(
-			ctx,
-			agentName,
-			next.agentModels[agentName],
-			"cancels agent changes",
-		);
-		if (modelChoice === undefined) return notifyCancelled(ctx);
-		const model = effectiveModelForChoice(ctx, modelChoice);
-		const strength = await pickAgentStrength(
-			ctx,
-			agentName,
-			model,
-			next.agentThinkingLevels[agentName],
-			actualAgentThinkingDefault(ctx, next, agentName),
-			"cancels agent changes",
-		);
-		if (strength === undefined) return notifyCancelled(ctx);
-		next.agentModels = applyAgentModelChoice(next.agentModels, agentName, modelChoice);
-		if (strength === AUTO_THINKING) delete next.agentThinkingLevels[agentName];
-		else next.agentThinkingLevels[agentName] = strength;
+		// Per-agent loop: model (+ thinking when the model exposes a choice), then
+		// back to the agent picker so several agents can be set in one pass. Esc
+		// at any step ends the loop; agents already configured in this pass are kept.
+		let configuredAny = false;
+		while (true) {
+			const picked = await configureOneAgent(ctx, next);
+			if (picked === undefined) break;
+			configuredAny = true;
+			next.agentModels = applyAgentModelChoice(next.agentModels, picked.name, picked.model);
+			if (picked.strength === AUTO_THINKING) delete next.agentThinkingLevels[picked.name];
+			else next.agentThinkingLevels[picked.name] = picked.strength;
+		}
+		if (!configuredAny) return notifyCancelled(ctx);
 	} else if (choice.startsWith("Change vision")) {
 		const visionModel = await pickVisionModel(ctx, config.visionModel);
 		if (visionModel === undefined) return notifyCancelled(ctx);