@bacnh85/pi-subagent 0.9.1 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.9.2 (2026-07-16)
+
+### Pi SDK compatibility
+
+- Removed use of the deleted `AuthStorage.inMemory()` API so delegated planner and other subagents start on Pi 0.80.10.
+
 ## 0.9.1 (2026-07-16)
 
 ### Activity-aware timeouts

package/extensions/index.ts

@@ -14,17 +14,14 @@
  */
 
 import * as path from "node:path";
-import type { Model } from "@earendil-works/pi-ai";
 import { StringEnum } from "@earendil-works/pi-ai";
 import {
-	AuthStorage,
 	CONFIG_DIR_NAME,
 	DynamicBorder,
 	type ExtensionAPI,
 	type ExtensionContext,
 	getAgentDir,
 	getMarkdownTheme,
-	ModelRegistry,
 	type ThemeColor,
 } from "@earendil-works/pi-coding-agent";
 import { Container, Markdown, SelectList, Spacer, Text } from "@earendil-works/pi-tui";
@@ -42,6 +39,7 @@ import {
 	startHeartbeat,
 } from "./runner.ts";
 import {
+	isRateLimitError,
 	normalizeTimeout,
 	resolveSafeCwd,
 	validateAgentTools,
@@ -463,20 +461,9 @@ export default function (pi: ExtensionAPI) {
 				}
 			}
 
-			// Shared auth/model setup for SDK sessions
-			// ponytail: reuse parent modelRegistry instead of a fresh copy — avoids
-			// internal API casts (storeModelHeaders) and preserves env/headers/OAuth.
-			const authStorage = AuthStorage.inMemory();
 			const modelRegistry = ctx.modelRegistry;
-
-			// Helper: inject parent's API key into child auth storage
-			async function injectApiKey(model: Model<any>): Promise<void> {
-				const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-				if (auth.ok) {
-					if (auth.apiKey) authStorage.setRuntimeApiKey(model.provider, auth.apiKey);
-					// ponytail: headers/env stay on the parent registry — no copy needed.
-				}
-			}
+			const modelRuntime = (modelRegistry as any).runtime;
+			const authStorage = (modelRegistry as any).authStorage;
 
 			// Helper: resolve a safe child working directory.
 			function resolveChildCwd(childCwd: string | undefined): string {
@@ -566,8 +553,6 @@ export default function (pi: ExtensionAPI) {
 				let effectiveTimeoutMs: number | undefined;
 				let safeCwd: string;
 				try {
-					// Inject parent's API key so --api-key and other runtime overrides work
-					await injectApiKey(resolved.model);
 					tools = resolveChildTools(agent.tools, agent.sandbox, isReadOnly);
 					effectiveTimeoutMs = resolveChildTimeout(timeoutMs, params.timeout);
 					safeCwd = resolveChildCwd(cwd);
@@ -586,28 +571,108 @@ export default function (pi: ExtensionAPI) {
 					};
 				}
 
+				// Retry loop: rate-limit model fallback
+				const candidates = getModelCandidates(agent);
+				const triedModels: string[] = [];
+
 				const stopHeartbeat = onUpdate ? startHeartbeat(() => {
 					onHeartbeat?.();
 					onUpdate({ content: [{ type: "text", text: `Subagent ${agentName} is still running…` }], details: heartbeatDetails?.() ?? makeDetails("single")([]) });
 				}) : undefined;
 				try {
-					return await runSubAgent({
-						cwd: safeCwd,
-						systemPrompt: params.instructions
-						? `${agent.systemPrompt}\n\n## Task Contract\n${params.instructions.slice(0, MAX_INSTRUCTIONS_LENGTH)}`
-						: agent.systemPrompt,
-						task,
-						tools,
-						model: resolved.model,
-						authStorage,
-						modelRegistry,
-						signal: parentSignal,
-						timeoutMs: effectiveTimeoutMs,
-						agentName,
-						thinkingLevel: agent.thinking,
-						onMessage: onProgress,
-						onProgress: onActivity,
-					});
+					const tryWithFallback = async (): Promise<SubAgentResult> => {
+						const remaining = candidates.filter(m => !triedModels.includes(m));
+						const isParentFallback = remaining.length === 0;
+						const fallbackResolved = await resolveModel(remaining, ctx.model, ctx.modelRegistry);
+						if (!fallbackResolved.model) {
+							return {
+								agent: agentName,
+								task,
+								exitCode: 1,
+								status: "error" as const,
+								stopReason: "error" as const,
+								messages: [],
+								stderr: [
+									`All models rate-limited or unavailable.`,
+									`Tried: ${triedModels.join(" → ") || "(none)"}.`,
+									`Remaining candidates: ${remaining.join(", ") || "none"}.`,
+									`Parent: ${ctx.model?.provider}/${ctx.model?.id}.`,
+								].join(" "),
+								usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+								errorMessage: `All models exhausted (tried: ${triedModels.join(" → ") || "none"})`,
+							};
+						}
+						const triedName = `${fallbackResolved.model!.provider}/${fallbackResolved.model!.id}`;
+						if (triedModels.includes(triedName)) {
+							// Already tried this model (e.g., all candidates unavailable
+							// and parent fallback) — no further options.
+							return {
+								agent: agentName,
+								task,
+								exitCode: 1,
+								status: "error" as const,
+								stopReason: "error" as const,
+								messages: [],
+								stderr: [
+									`All available models exhausted.`,
+									`Tried: ${triedModels.join(" → ")}.`,
+								].join(" "),
+								usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+								errorMessage: `All available models exhausted (tried: ${triedModels.join(" → ")})`,
+							};
+						}
+						triedModels.push(triedName);
+						// Also track the raw candidate name so candidates.filter() can
+						// exclude it even when the agent uses unqualified names.
+						// Avoid duplicating when candidate name is already qualified (matchedCandidate === triedName).
+						if (fallbackResolved.matchedCandidate && fallbackResolved.matchedCandidate !== triedName) {
+							triedModels.push(fallbackResolved.matchedCandidate);
+						}
+
+						const result = await runSubAgent({
+							cwd: safeCwd,
+							systemPrompt: params.instructions
+							? `${agent.systemPrompt}\n\n## Task Contract\n${params.instructions.slice(0, MAX_INSTRUCTIONS_LENGTH)}`
+							: agent.systemPrompt,
+							task,
+							tools,
+							model: fallbackResolved.model,
+							modelRuntime,
+							authStorage,
+							modelRegistry,
+							signal: parentSignal,
+							timeoutMs: effectiveTimeoutMs,
+							agentName,
+							thinkingLevel: agent.thinking,
+							onMessage: onProgress,
+							onProgress: onActivity,
+						});
+
+						if (result.errorMessage && isRateLimitError(result.errorMessage)) {
+							// If the model that just rate-limited was the parent fallback
+							// (no remaining candidates), stop — no further options.
+							if (isParentFallback) {
+								return {
+									agent: agentName,
+									task,
+									exitCode: 1,
+									status: "error" as const,
+									stopReason: "error" as const,
+									messages: [],
+									stderr: [
+										`All available models exhausted.`,
+										`Tried: ${triedModels.join(" → ")}.`,
+									].join(" "),
+									usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+									errorMessage: `All available models exhausted (tried: ${triedModels.join(" → ")})`,
+								};
+							}
+							return tryWithFallback();
+						}
+						return result;
+					};
+
+					return tryWithFallback();
 				} finally {
 					stopHeartbeat?.();
 				}

package/extensions/model.ts

@@ -17,6 +17,8 @@ import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
 export interface ResolvedModel {
 	model: Model<any> | null;
 	attempted: string[];
+	/** The raw candidate name that matched, if a candidate resolved. Undefined for parent fallback. */
+	matchedCandidate?: string;
 }
 
 /** Known provider prefixes for unqualified model names. */
@@ -47,16 +49,16 @@ export async function resolveModel(
 		const idx = modelName.indexOf("/");
 		if (idx > 0) {
 			const found = tryAvailable(modelName);
-			if (found) return { model: found, attempted };
+			if (found) return { model: found, attempted, matchedCandidate: modelName };
 			continue;
 		}
 		for (const [provider, pattern] of KNOWN_PROVIDERS) {
 			if (!pattern.test(modelName)) continue;
 			const found = tryAvailable(`${provider}/${modelName}`);
-			if (found) return { model: found, attempted };
+			if (found) return { model: found, attempted, matchedCandidate: modelName };
 		}
 		const found = tryAvailable(`anthropic/${modelName}`);
-		if (found) return { model: found, attempted };
+		if (found) return { model: found, attempted, matchedCandidate: modelName };
 	}
 
 	if (parentModel) {

package/extensions/runner.ts

@@ -17,10 +17,8 @@
 import type { Message, Model } from "@earendil-works/pi-ai";
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import {
-	AuthStorage,
 	createAgentSession,
 	createExtensionRuntime,
-	ModelRegistry,
 	type ResourceLoader,
 	SessionManager,
 	SettingsManager,
@@ -87,8 +85,11 @@ export async function runSubAgent(options: {
 	task: string;
 	tools: string[];
 	model: Model<any>;
-	authStorage: AuthStorage;
-	modelRegistry: ModelRegistry;
+	/** Pi 0.80.10's canonical credential/model runtime. */
+	modelRuntime?: unknown;
+	/** Legacy Pi SDK session options retained for 0.80.6 tests and hosts. */
+	authStorage?: unknown;
+	modelRegistry?: unknown;
 	signal?: AbortSignal;
 	agentName?: string;
 	thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
@@ -98,7 +99,7 @@ export async function runSubAgent(options: {
 	hardTimeoutMs?: number;
 }): Promise<SubAgentResult> {
 	const {
-		cwd, systemPrompt, task, tools, model, authStorage, modelRegistry, signal,
+		cwd, systemPrompt, task, tools, model, modelRuntime, authStorage, modelRegistry, signal,
 		agentName = "subagent", thinkingLevel = "off", onMessage, onProgress,
 		timeoutMs = DEFAULT_INACTIVITY_TIMEOUT_MS, hardTimeoutMs = HARD_TIMEOUT_MS,
 	} = options;
@@ -142,7 +143,12 @@ export async function runSubAgent(options: {
 			result.status = classifyStopReason(result.stopReason, !timedOut, timedOut);
 			return result;
 		}
-		const { session } = await createAgentSession({ cwd, model, thinkingLevel, authStorage, modelRegistry, resourceLoader, tools, sessionManager: SessionManager.inMemory(cwd), settingsManager });
+		const { session } = await createAgentSession({
+			cwd, model, thinkingLevel, resourceLoader, tools, sessionManager: SessionManager.inMemory(cwd), settingsManager,
+			...(modelRuntime ? { modelRuntime } : {}),
+			// Pi 0.80.10 owns credentials in ModelRuntime; older SDKs still accept these.
+			...(authStorage ? { authStorage, modelRegistry } : {}),
+		} as any);
 		let unsubscribe: (() => void) | undefined;
 		let removeAbort: (() => void) | undefined;
 		try {

package/extensions/security.ts

@@ -501,3 +501,33 @@ export function truncateParallelOutput(output: string): string {
 	}
 	return `${truncated}\n\n[Output truncated: ${byteLength - Buffer.byteLength(truncated, "utf8")} bytes omitted.]`;
 }
+
+// ---------------------------------------------------------------------------
+// Rate-limit error detection
+// ---------------------------------------------------------------------------
+
+const RATE_LIMIT_PATTERNS = [
+	/\b429\b/,
+	/\b529\b/,
+	/rate[\s_]limit/i,
+	/ratelimit/i,
+	/too[\s_]many[\s_]requests/i,
+	/quota[\s_]exhausted/i,
+	/quota[\s_]exceeded/i,
+	/exceeded[\s_](?:your[\s_])?(?:current[\s_])?quota/i,
+	/insufficient_quota/i,
+	/resource[\s_]exhausted/i,
+	/capacity[\s_]exceeded/i,
+	/usage[\s_]limit/i,
+	/overloaded/i,
+];
+
+/**
+ * Check if an error message indicates a rate-limit / quota-exhaustion condition.
+ *
+ * Used by the sub-agent runtime to trigger automatic model fallback when the
+ * primary model candidate hits a 429 or similar server-side capacity error.
+ */
+export function isRateLimitError(message: string): boolean {
+	return RATE_LIMIT_PATTERNS.some(p => p.test(message));
+}

package/extensions/service.ts

@@ -1,8 +1,9 @@
-import { AuthStorage, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type AgentConfig, getModelCandidates } from "./agents.ts";
 import { runSubAgent, type SubAgentProgress, type SubAgentResult } from "./runner.ts";
 import { resolveModel } from "./model.ts";
 import {
+	isRateLimitError,
 	validateAgentTools,
 	normalizeTimeout,
 	resolveSafeCwd,
@@ -44,13 +45,9 @@ export async function runNamedAgent(options: {
 	const { model, attempted } = await resolveModel(getModelCandidates(options.agent), options.ctx.model, options.ctx.modelRegistry);
 	if (!model) throw new Error(`No model resolved for agent "${options.agent.name}" (tried: ${attempted.join(", ") || "none"})`);
 
-	const authStorage = AuthStorage.inMemory();
 	const modelRegistry = options.ctx.modelRegistry;
-	const auth = await options.ctx.modelRegistry.getApiKeyAndHeaders(model);
-	if (auth.ok) {
-		if (auth.apiKey) authStorage.setRuntimeApiKey(model.provider, auth.apiKey);
-		// ponytail: env and headers stay on the parent modelRegistry — reuse it directly.
-	}
+	const modelRuntime = (modelRegistry as any).runtime;
+	const authStorage = (modelRegistry as any).authStorage;
 
 	// Security: validate and normalise timeout.
 	const effectiveTimeoutMs = normalizeTimeout({ requested: options.timeout }).timeoutMs;
@@ -76,13 +73,44 @@ export async function runNamedAgent(options: {
 
 	const contract = options.instructions?.slice(0, MAX_INSTRUCTIONS_LENGTH);
 
-	try {
+	// Retry loop: rate-limit model fallback
+	const candidates = getModelCandidates(options.agent);
+	const triedModels: string[] = [];
+
+	const tryWithFallback = async (): Promise<SubAgentResult> => {
+		const remaining = candidates.filter(m => !triedModels.includes(m));
+		const isParentFallback = remaining.length === 0;
+		const fallbackResolved = await resolveModel(remaining, options.ctx.model, options.ctx.modelRegistry);
+		if (!fallbackResolved.model) {
+			throw new Error(
+				`All models rate-limited or unavailable. Tried: ${triedModels.join(" → ") || "(none)"}. ` +
+				`Remaining candidates: ${remaining.join(", ") || "none"}. ` +
+				`Parent: ${options.ctx.model?.provider}/${options.ctx.model?.id}.`,
+			);
+		}
+		const triedName = `${fallbackResolved.model!.provider}/${fallbackResolved.model!.id}`;
+		if (triedModels.includes(triedName)) {
+			// Already tried this model (e.g., all candidates unavailable
+			// and parent fallback) — no further options.
+			throw new Error(
+				`All available models exhausted. Tried: ${triedModels.join(" → ")}.`,
+			);
+		}
+		triedModels.push(triedName);
+		// Also track the raw candidate name so candidates.filter() can
+		// exclude it even when the agent uses unqualified names.
+		// Avoid duplicating when candidate name is already qualified (matchedCandidate === triedName).
+		if (fallbackResolved.matchedCandidate && fallbackResolved.matchedCandidate !== triedName) {
+			triedModels.push(fallbackResolved.matchedCandidate);
+		}
+
 		const result = await runSubAgent({
 			cwd: safeCwd.path,
 			systemPrompt: contract ? `${options.agent.systemPrompt}\n\n## Task Contract\n${contract}` : options.agent.systemPrompt,
 			task: options.task,
 			tools: toolValidation.tools,
-			model,
+			model: fallbackResolved.model,
+			modelRuntime,
 			authStorage,
 			modelRegistry,
 			signal: options.signal,
@@ -92,7 +120,22 @@ export async function runNamedAgent(options: {
 			onMessage: options.onMessage,
 			onProgress: options.onProgress,
 		});
+
+		if (result.errorMessage && isRateLimitError(result.errorMessage)) {
+			// If the model that just rate-limited was the parent fallback
+			// (no remaining candidates), stop — no further options.
+			if (isParentFallback) {
+				throw new Error(
+					`All available models exhausted. Tried: ${triedModels.join(" → ")}.`,
+				);
+			}
+			return tryWithFallback();
+		}
 		return result;
+	};
+
+	try {
+		return await tryWithFallback();
 	} finally {
 		// No manual timeout handling needed — runSubAgent handles timeouts internally.
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-subagent",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "In-process subagents for Pi with isolated SDK sessions, parallel and chained delegation, and inspectable threads.",
   "type": "module",
   "license": "MIT",