@bacnh85/pi-subagent 0.9.2 → 0.10.0

package/extensions/index.ts

@@ -39,6 +39,7 @@ import {
 	startHeartbeat,
 } from "./runner.ts";
 import {
+	isRateLimitError,
 	normalizeTimeout,
 	resolveSafeCwd,
 	validateAgentTools,
@@ -570,29 +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,
-						modelRuntime,
-						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/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

@@ -3,6 +3,7 @@ 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,
@@ -72,13 +73,43 @@ 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,
@@ -89,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.2",
+  "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",