@selesai/code 0.9.10 → 0.9.12

package/dist/extensions/pi-subagents/test/unit/model-exclusions.test.ts

@@ -0,0 +1,167 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import {
+	clearExclusions,
+	filterFallbackCandidates,
+	flushPersist,
+	getExcludedCount,
+	getExclusionsFilePath,
+	isExcluded,
+	parseModelKey,
+	recordModelFailure,
+	reloadFromDisk,
+	setDefaultTTL,
+} from "../../src/runs/shared/model-exclusions.ts";
+
+// The exclusion store is a process-wide singleton persisted under TEMP_ROOT_DIR
+// (isolated per test run by test/support/isolated-temp-root.mjs). Clear it
+// before/after each test so cases don't leak state into each other.
+beforeEach(() => {
+	fs.rmSync(getExclusionsFilePath(), { force: true });
+	clearExclusions();
+});
+afterEach(() => clearExclusions());
+
+describe("model exclusions — record & query", () => {
+	it("excludes a recorded model", () => {
+		recordModelFailure({ modelId: "gpt-4", provider: "openai", reason: "429" });
+		assert.equal(isExcluded("gpt-4", "openai"), true);
+	});
+
+	it("does not exclude other models of the same provider when modelId is set", () => {
+		recordModelFailure({ modelId: "gpt-4", provider: "openai" });
+		assert.equal(isExcluded("gpt-4o", "openai"), false);
+	});
+
+	it("does not exclude the same modelId under a different provider", () => {
+		recordModelFailure({ modelId: "gpt-4", provider: "openai" });
+		assert.equal(isExcluded("gpt-4", "github-copilot"), false);
+	});
+
+	it("matches by provider when modelId is omitted", () => {
+		recordModelFailure({ provider: "openai", reason: "quota" });
+		assert.equal(isExcluded("any-model", "openai"), true);
+	});
+
+	it("deduplicates repeated recordings for the same key", () => {
+		recordModelFailure({ modelId: "gpt-4", provider: "openai" });
+		recordModelFailure({ modelId: "gpt-4", provider: "openai" });
+		assert.equal(getExcludedCount(), 1);
+	});
+
+	it("tracks distinct keys separately", () => {
+		recordModelFailure({ modelId: "gpt-4", provider: "openai" });
+		recordModelFailure({ modelId: "claude", provider: "anthropic" });
+		assert.equal(getExcludedCount(), 2);
+	});
+});
+
+describe("model exclusions — TTL expiry", () => {
+	it("rejects invalid default TTLs", () => {
+		assert.throws(() => setDefaultTTL(0), /finite positive/);
+		assert.throws(() => setDefaultTTL(Number.POSITIVE_INFINITY), /finite positive/);
+	});
+
+	it("drops an exclusion after its TTL elapses", async () => {
+		recordModelFailure({ modelId: "gpt-4", provider: "openai", ttlMs: 100 });
+		assert.equal(isExcluded("gpt-4", "openai"), true);
+		await new Promise((r) => setTimeout(r, 150));
+		assert.equal(isExcluded("gpt-4", "openai"), false);
+	});
+});
+
+describe("model exclusions — parseModelKey", () => {
+	it("splits provider and modelId", () => {
+		assert.deepEqual(parseModelKey("openai/gpt-4"), { provider: "openai", modelId: "gpt-4" });
+	});
+
+	it("strips a thinking suffix before parsing", () => {
+		assert.deepEqual(parseModelKey("openai/gpt-5:high"), { provider: "openai", modelId: "gpt-5" });
+	});
+
+	it("preserves variant tags before stripping a known thinking suffix", () => {
+		assert.deepEqual(parseModelKey("ollama-cloud/deepseek-v4-flash:0731:high"), {
+			provider: "ollama-cloud",
+			modelId: "deepseek-v4-flash:0731",
+		});
+	});
+
+	it("keeps slashes inside the modelId", () => {
+		assert.deepEqual(parseModelKey("openrouter/google/gemini-flash"), {
+			provider: "openrouter",
+			modelId: "google/gemini-flash",
+		});
+	});
+
+	it("handles a bare model id without a provider", () => {
+		assert.deepEqual(parseModelKey("gpt-4"), { modelId: "gpt-4" });
+	});
+});
+
+describe("model exclusions — filtering fallback candidates", () => {
+	it("removes excluded candidates from a candidate list", () => {
+		const candidates = ["anthropic/claude-3", "openai/gpt-4", "openai/gpt-4o"];
+		recordModelFailure({ provider: "openai" });
+		const filtered = filterFallbackCandidates(candidates);
+		assert.deepEqual(filtered, ["anthropic/claude-3"]);
+	});
+
+	it("removes a candidate recorded with a thinking suffix", () => {
+		const candidates = ["anthropic/claude-3", "openai/gpt-5:high"];
+		recordModelFailure({ modelId: "gpt-5", provider: "openai" });
+		const filtered = filterFallbackCandidates(candidates);
+		assert.deepEqual(filtered, ["anthropic/claude-3"]);
+	});
+
+	it("keeps unexcluded candidates and de-duplicates", () => {
+		const candidates = ["anthropic/claude-3", "anthropic/claude-3", "openai/gpt-4"];
+		const filtered = filterFallbackCandidates(candidates);
+		assert.deepEqual(filtered, ["anthropic/claude-3", "openai/gpt-4"]);
+	});
+});
+
+describe("model exclusions — persistence", () => {
+	it("survives a reload from disk", () => {
+		recordModelFailure({ modelId: "gpt-4", provider: "openai", reason: "429" });
+		reloadFromDisk();
+		assert.equal(isExcluded("gpt-4", "openai"), true);
+	});
+
+	it("persists a recorded model failure before process exit", () => {
+		const file = getExclusionsFilePath();
+		fs.rmSync(file, { force: true });
+		reloadFromDisk();
+		recordModelFailure({ modelId: "gpt-4", provider: "openai", reason: "429" });
+		assert.equal(fs.existsSync(file), true);
+		reloadFromDisk();
+		assert.equal(isExcluded("gpt-4", "openai"), true);
+	});
+
+	it("does not reload expired exclusions", () => {
+		recordModelFailure({ modelId: "gpt-4", provider: "openai", ttlMs: 1 });
+		flushPersist();
+		return new Promise<void>((resolve) => {
+			setTimeout(() => {
+				reloadFromDisk();
+				assert.equal(isExcluded("gpt-4", "openai"), false);
+				resolve();
+			}, 20);
+		});
+	});
+
+	it("reports corrupt persisted exclusions and starts empty", () => {
+		fs.writeFileSync(getExclusionsFilePath(), "not json", "utf-8");
+		const originalError = console.error;
+		const errors: unknown[][] = [];
+		console.error = (...args: unknown[]) => errors.push(args);
+		try {
+			reloadFromDisk();
+		} finally {
+			console.error = originalError;
+		}
+		assert.equal(getExcludedCount(), 0);
+		assert.equal(errors.length, 1);
+		assert.match(String(errors[0]?.[0]), /Failed to load exclusions/);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/model-fallback.test.ts

@@ -1,16 +1,22 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { afterEach, beforeEach, describe, it } from "node:test";
 import {
 	buildModelCandidates,
-	formatModelRetryNote,
 	fuzzyResolveModel,
+	formatSubagentModelVerificationError,
+	isContextOverflow,
 	isRetryableModelFailure,
-	MODEL_RETRY_DELAYS_MS,
 	normalizeModelSegment,
+	recordRetryableModelFailure,
 	resolveEffectiveSubagentModel,
 	resolveModelCandidate,
 	resolveSubagentModelOverride,
 } from "../../src/runs/shared/model-fallback.ts";
+import { clearExclusions } from "../../src/runs/shared/model-exclusions.ts";
+import { resolveModelScopesForAgent } from "../../src/runs/shared/model-scope.ts";
+
+beforeEach(() => clearExclusions());
+afterEach(() => clearExclusions());
 
 describe("model fallback helpers", () => {
 	const availableModels = [
@@ -22,6 +28,67 @@ describe("model fallback helpers", () => {
 		assert.equal(resolveModelCandidate("openai/gpt-5-mini", availableModels), "openai/gpt-5-mini");
 	});
 
+	it("fails verification when the child reports an unregistered different model", () => {
+		assert.match(
+			formatSubagentModelVerificationError("openai/gpt-5-mini:high", "unknown-provider/wrong-model", availableModels) ?? "",
+			/model_verification_failed/,
+		);
+	});
+
+	it("accepts child-reported bare model ids for the expected registry entry", () => {
+		assert.equal(
+			formatSubagentModelVerificationError("openai/gpt-5-mini:high", "gpt-5-mini", availableModels),
+			undefined,
+		);
+	});
+
+	it("preserves variant tags when verifying provider-qualified model ids", () => {
+		assert.equal(
+			formatSubagentModelVerificationError(
+				"ollama-cloud/deepseek-v4-flash:0731:high",
+				"deepseek-v4-flash:0731",
+				[{ provider: "ollama-cloud", id: "deepseek-v4-flash:0731", fullId: "ollama-cloud/deepseek-v4-flash:0731" }],
+			),
+			undefined,
+		);
+	});
+
+	it("resolves unique owner/name ids when the owner is not a registered provider", () => {
+		const registry = [
+			...availableModels,
+			{ provider: "huggingface", id: "thinkingmachines/Inkling", fullId: "huggingface/thinkingmachines/Inkling" },
+		];
+		assert.equal(resolveModelCandidate("thinkingmachines/Inkling", registry), "huggingface/thinkingmachines/Inkling");
+		assert.equal(
+			resolveModelCandidate("huggingface/thinkingmachines/Inkling", registry),
+			"huggingface/thinkingmachines/Inkling",
+		);
+		assert.equal(
+			resolveModelCandidate("thinkingmachines/Inkling:high", registry),
+			"huggingface/thinkingmachines/Inkling:high",
+		);
+	});
+
+	it("prefers the current provider for an ambiguous owner/name id", () => {
+		const registry = [
+			{ provider: "huggingface", id: "thinkingmachines/Inkling", fullId: "huggingface/thinkingmachines/Inkling" },
+			{ provider: "together", id: "thinkingmachines/Inkling", fullId: "together/thinkingmachines/Inkling" },
+		];
+		assert.equal(resolveModelCandidate("thinkingmachines/Inkling", registry), "thinkingmachines/Inkling");
+		assert.equal(
+			resolveModelCandidate("thinkingmachines/Inkling", registry, "huggingface"),
+			"huggingface/thinkingmachines/Inkling",
+		);
+	});
+
+	it("treats a registered provider prefix as provider/id, not owner/name", () => {
+		const registry = [
+			{ provider: "openai", id: "gpt-5-mini", fullId: "openai/gpt-5-mini" },
+			{ provider: "huggingface", id: "openai/gpt-5-mini", fullId: "huggingface/openai/gpt-5-mini" },
+		];
+		assert.equal(resolveModelCandidate("openai/gpt-5-mini", registry), "openai/gpt-5-mini");
+	});
+
 	it("resolves a bare id when there is exactly one registry match", () => {
 		assert.equal(resolveModelCandidate("gpt-5-mini", availableModels), "openai/gpt-5-mini");
 	});
@@ -57,6 +124,24 @@ describe("model fallback helpers", () => {
 		);
 	});
 
+	it("excludes a candidate after a retryable model failure is recorded", () => {
+		recordRetryableModelFailure("openai/gpt-5-mini", "rate limit exceeded");
+
+		assert.deepEqual(
+			buildModelCandidates("gpt-5-mini", ["anthropic/claude-sonnet-4"], availableModels),
+			["anthropic/claude-sonnet-4"],
+		);
+	});
+
+	it("does not exclude a candidate after a task or tool failure", () => {
+		recordRetryableModelFailure("openai/gpt-5-mini", "bash failed (exit 1): command not found");
+
+		assert.deepEqual(
+			buildModelCandidates("gpt-5-mini", ["anthropic/claude-sonnet-4"], availableModels),
+			["openai/gpt-5-mini", "anthropic/claude-sonnet-4"],
+		);
+	});
+
 	it("applies the current provider preference to fallback candidates too", () => {
 		const ambiguous = [
 			...availableModels,
@@ -68,33 +153,44 @@ describe("model fallback helpers", () => {
 		);
 	});
 
-	it("rejects fallback models that the active registry cannot resolve", () => {
+	it("skips unavailable fallback models and warns once for each", () => {
+		const warnings: string[] = [];
+		const originalWarn = console.warn;
+		console.warn = (message: unknown) => warnings.push(String(message));
+		try {
+			assert.deepEqual(
+				buildModelCandidates("gpt-5-mini", ["does-not-exist", "also-unavailable"], availableModels),
+				["openai/gpt-5-mini"],
+			);
+		} finally {
+			console.warn = originalWarn;
+		}
+		assert.deepEqual(warnings, [
+			"[pi-subagents] Skipping fallback model 'does-not-exist' because it is unavailable in this environment.",
+			"[pi-subagents] Skipping fallback model 'also-unavailable' because it is unavailable in this environment.",
+		]);
+	});
+
+	it("trusts an inherited parent model outside the registry", () => {
+		assert.deepEqual(
+			buildModelCandidates("gateway/parent-model", undefined, availableModels, undefined, { primaryModelFromParent: true }),
+			["gateway/parent-model"],
+		);
 		assert.throws(
-			() => buildModelCandidates("gpt-5-mini", ["does-not-exist"], availableModels),
-			/Unknown subagent model 'does-not-exist'/,
+			() => buildModelCandidates("gateway/parent-model", undefined, availableModels),
+			/Unknown subagent model 'gateway\/parent-model'/,
 		);
 	});
 
 	it("detects retryable provider/model failures", () => {
 		assert.equal(isRetryableModelFailure("rate limit exceeded for provider"), true);
+		assert.equal(isRetryableModelFailure("The usage limit has been reached"), true);
 		assert.equal(isRetryableModelFailure("model unavailable"), true);
 		assert.equal(isRetryableModelFailure("authentication failed"), true);
 		assert.equal(isRetryableModelFailure("Subagent produced no output (possible model cold-start or empty response)."), true);
 		assert.equal(isRetryableModelFailure("model load failed"), true);
 		assert.equal(isRetryableModelFailure("Stream ended without finish_reason"), true);
 		assert.equal(isRetryableModelFailure("Request timed out."), true);
-		assert.equal(isRetryableModelFailure("503 Service Unavailable"), true);
-		assert.equal(isRetryableModelFailure("No body returned for response"), true);
-		assert.equal(isRetryableModelFailure("no response body"), true);
-		assert.equal(isRetryableModelFailure("ECONNRESET"), true);
-	});
-
-	it("ships a bounded same-model retry schedule and note", () => {
-		assert.deepEqual(MODEL_RETRY_DELAYS_MS, [500, 1500, 4000]);
-		assert.match(
-			formatModelRetryNote({ model: "anthropic/claude-sonnet-4", attempt: 1, maxAttempts: 4, delayMs: 500 }),
-			/\[model-retry\] anthropic\/claude-sonnet-4.*attempt 1\/4.*500ms/,
-		);
 	});
 
 	it("does not treat ordinary task/tool failures as retryable model failures", () => {
@@ -168,6 +264,17 @@ describe("resolveSubagentModelOverride (cross-session inherit, issue #266)", ()
 		);
 	});
 
+	it("resolves owner/name frontmatter models against the registry", () => {
+		const models = [
+			...availableModels,
+			{ provider: "huggingface", id: "thinkingmachines/Inkling", fullId: "huggingface/thinkingmachines/Inkling" },
+		];
+		assert.equal(
+			resolveSubagentModelOverride("thinkingmachines/Inkling", parentModel, models, "huggingface"),
+			"huggingface/thinkingmachines/Inkling",
+		);
+	});
+
 	it("rejects explicit models that the active registry cannot resolve", () => {
 		assert.throws(
 			() => resolveSubagentModelOverride("does-not-exist", parentModel, availableModels),
@@ -179,6 +286,28 @@ describe("resolveSubagentModelOverride (cross-session inherit, issue #266)", ()
 		);
 	});
 
+	it("suggests a unique alternate provider without resolving across providers", () => {
+		assert.throws(
+			() => resolveSubagentModelOverride("openai/claude-sonnet-4:high", parentModel, availableModels),
+			/Unknown subagent model 'openai\/claude-sonnet-4:high'.*Did you mean 'anthropic\/claude-sonnet-4:high'\?/,
+		);
+	});
+
+	it("does not suggest an alternate provider when the bare id is ambiguous or absent", () => {
+		const ambiguous = [
+			...availableModels,
+			{ provider: "github-copilot", id: "claude-sonnet-4", fullId: "github-copilot/claude-sonnet-4" },
+		];
+		assert.throws(
+			() => resolveSubagentModelOverride("openai/claude-sonnet-4", parentModel, ambiguous),
+			(error: unknown) => !String(error).includes("Did you mean"),
+		);
+		assert.throws(
+			() => resolveSubagentModelOverride("openai/does-not-exist", parentModel, availableModels),
+			(error: unknown) => !String(error).includes("Did you mean"),
+		);
+	});
+
 	it("returns undefined when inheriting but no parent model is known", () => {
 		// No parent session model available: fall back to the prior behavior of
 		// emitting no override rather than inventing an invalid one.
@@ -217,6 +346,18 @@ describe("resolveEffectiveSubagentModel", () => {
 		);
 		assert.equal(warnings.length, 1);
 	});
+
+	it("uses the preferred provider for an ambiguous agent model", () => {
+		const registry = [
+			...availableModels,
+			{ provider: "gpu-b", id: "gpt-5-mini", fullId: "gpu-b/gpt-5-mini" },
+		];
+
+		assert.equal(
+			resolveEffectiveSubagentModel(undefined, "gpt-5-mini", undefined, registry, "gpu-b"),
+			"gpu-b/gpt-5-mini",
+		);
+	});
 });
 
 describe("fuzzyResolveModel / normalizeModelSegment", () => {
@@ -263,6 +404,18 @@ describe("fuzzyResolveModel / normalizeModelSegment", () => {
 		assert.equal(fuzzyResolveModel("anthropic/claude.haiku.4.5", registry), "anthropic/claude-haiku-4-5");
 	});
 
+	it("fuzzy-matches owner/name ids when the owner is not a registered provider", () => {
+		const hfRegistry = [
+			...registry,
+			{ provider: "huggingface", id: "thinkingmachines/Inkling", fullId: "huggingface/thinkingmachines/Inkling" },
+		];
+		assert.equal(fuzzyResolveModel("ThinkingMachines/Inkling", hfRegistry), "huggingface/thinkingmachines/Inkling");
+		assert.equal(
+			fuzzyResolveModel("huggingface/ThinkingMachines/Inkling", hfRegistry),
+			"huggingface/thinkingmachines/Inkling",
+		);
+	});
+
 	it("does not switch providers for a qualified query", () => {
 		// Named provider has no such model; do not fall back to another provider.
 		assert.equal(fuzzyResolveModel("openai/claude-sonnet-4", registry), undefined);
@@ -344,6 +497,116 @@ describe("resolveSubagentModelOverride scope enforcement", () => {
 		);
 	});
 
+	it("identifies the per-agent scope that rejects an explicit model", () => {
+		const scopes = resolveModelScopesForAgent(
+			{ enforce: true, allow: ["openai/*", "deepseek/*"], agents: { worker: { allow: ["openai/gpt-5-mini"] } } },
+			"worker",
+			parentModel,
+		);
+		assert.throws(
+			() => resolveEffectiveSubagentModel("deepseek/deepseek-v4", undefined, parentModel, availableModels, undefined, { scope: scopes }),
+			/modelScope\.agents\.worker/,
+		);
+	});
+
+	it("allows an inherited parent model through an inherit agent scope", () => {
+		const scopes = resolveModelScopesForAgent(
+			{ enforce: true, agents: { reviewer: { allow: ["inherit"] } } },
+			"reviewer",
+			parentModel,
+		);
+		assert.equal(resolveEffectiveSubagentModel(undefined, undefined, parentModel, availableModels, undefined, { scope: scopes }), "deepseek/deepseek-v4");
+	});
+
+	it("fails closed when enforced inherit cannot resolve a parent model", () => {
+		const scopes = resolveModelScopesForAgent(
+			{ enforce: true, agents: { reviewer: { allow: ["inherit"] } } },
+			"reviewer",
+			undefined,
+		);
+		assert.throws(
+			() => resolveEffectiveSubagentModel(undefined, undefined, undefined, availableModels, undefined, { scope: scopes }),
+			/modelScope\.agents\.reviewer.*requires a current parent session model/,
+		);
+	});
+
+	it("fails closed before using an agent fallback when enforced inherit has no parent model", () => {
+		const scopes = resolveModelScopesForAgent(
+			{ enforce: true, agents: { reviewer: { allow: ["inherit"] } } },
+			"reviewer",
+			undefined,
+		);
+		for (const explicitModel of [undefined, "inherit"] as const) {
+			assert.throws(
+				() => resolveEffectiveSubagentModel(explicitModel, "openai/gpt-5-mini", undefined, availableModels, undefined, { scope: scopes }),
+				/modelScope\.agents\.reviewer.*requires a current parent session model/,
+			);
+		}
+	});
+
+	it("fails closed before using fallback candidates when enforced inherit has no parent model", () => {
+		const scopes = resolveModelScopesForAgent(
+			{ enforce: true, agents: { worker: { allow: ["inherit"] } } },
+			"worker",
+			undefined,
+		);
+		assert.throws(
+			() => buildModelCandidates(undefined, ["openai/gpt-5-mini"], availableModels, undefined, { scope: scopes }),
+			/modelScope\.agents\.worker.*requires a current parent session model/,
+		);
+	});
+
+	it("fails closed for mixed inherit scopes before omitting the model", () => {
+		const scopes = resolveModelScopesForAgent(
+			{ enforce: true, agents: { worker: { allow: ["inherit", "openai/gpt-5-*"] } } },
+			"worker",
+			undefined,
+		);
+		assert.throws(
+			() => resolveEffectiveSubagentModel(undefined, undefined, undefined, availableModels, undefined, { scope: scopes }),
+			/modelScope\.agents\.worker.*requires a current parent session model/,
+		);
+		assert.throws(
+			() => buildModelCandidates(undefined, ["openai/gpt-5-mini"], availableModels, undefined, { scope: scopes }),
+			/modelScope\.agents\.worker.*requires a current parent session model/,
+		);
+	});
+
+	it("allows an explicit model through a mixed inherit scope without a parent", () => {
+		const scopes = resolveModelScopesForAgent(
+			{ enforce: true, agents: { worker: { allow: ["inherit", "openai/gpt-5-*"] } } },
+			"worker",
+			undefined,
+		);
+		assert.equal(resolveEffectiveSubagentModel("openai/gpt-5-mini", undefined, undefined, availableModels, undefined, { scope: scopes }), "openai/gpt-5-mini");
+	});
+
+	it("fails closed before using an agent model through a mixed inherit scope without a parent", () => {
+		const scopes = resolveModelScopesForAgent(
+			{ enforce: true, agents: { worker: { allow: ["inherit", "openai/gpt-5-*"] } } },
+			"worker",
+			undefined,
+		);
+		assert.throws(
+			() => resolveEffectiveSubagentModel(undefined, "openai/gpt-5-mini", undefined, availableModels, undefined, { scope: scopes }),
+			/modelScope\.agents\.worker.*requires a current parent session model/,
+		);
+	});
+
+	it("throws the strict agent violation before emitting a global warning", () => {
+		const warnings: string[] = [];
+		const scopes = resolveModelScopesForAgent(
+			{ enforce: true, allow: ["openai/*"], agents: { worker: { strict: true, allow: ["anthropic/*"] } } },
+			"worker",
+			parentModel,
+		);
+		assert.throws(
+			() => resolveEffectiveSubagentModel(undefined, undefined, parentModel, availableModels, undefined, { scope: scopes, onWarn: (violation) => warnings.push(violation.message) }),
+			/modelScope\.agents\.worker/,
+		);
+		assert.deepEqual(warnings, []);
+	});
+
 	it("warns (and still returns the model) for an inherited out-of-scope model", () => {
 		const warnings: string[] = [];
 		const resolved = resolveSubagentModelOverride("deepseek/deepseek-v4", parentModel, availableModels, undefined, {
@@ -438,4 +701,42 @@ describe("resolveSubagentModelOverride scope enforcement", () => {
 			/deepseek\/deepseek-v4.*outside the configured subagent model scope/,
 		);
 	});
+
+	it("applies a strict per-agent scope to fallback candidates", () => {
+		const scopes = resolveModelScopesForAgent(
+			{ enforce: true, strict: true, agents: { worker: { allow: ["openai/*"] } } },
+			"worker",
+			parentModel,
+		);
+		assert.throws(
+			() => buildModelCandidates("openai/gpt-5-mini", ["deepseek/deepseek-v4"], availableModels, undefined, { scope: scopes }),
+			/modelScope\.agents\.worker/,
+		);
+	});
+});
+
+describe("isContextOverflow", () => {
+	it("detects common context-overflow error shapes", () => {
+		assert.equal(isContextOverflow("This model's maximum context length is 8192 tokens"), true);
+		assert.equal(isContextOverflow("context length exceeded for the requested prompt"), true);
+		assert.equal(isContextOverflow("too many tokens in the request"), true);
+		assert.equal(isContextOverflow("context_length_exceeded"), true);
+		assert.equal(isContextOverflow("prompt is too long for this model"), true);
+		assert.equal(isContextOverflow("input too long: 40000 tokens"), true);
+	});
+
+	it("does not flag unrelated retryable failures as overflow", () => {
+		assert.equal(isContextOverflow("rate limit exceeded for provider"), false);
+		assert.equal(isContextOverflow("503 service unavailable"), false);
+		assert.equal(isContextOverflow("connection refused"), false);
+	});
+
+	it("does not flag tool failures as overflow", () => {
+		assert.equal(isContextOverflow("bash failed (exit 1): context length exceeded in output"), false);
+	});
+
+	it("returns false for empty or undefined input", () => {
+		assert.equal(isContextOverflow(undefined), false);
+		assert.equal(isContextOverflow(""), false);
+	});
 });

package/dist/extensions/pi-subagents/test/unit/model-info.test.ts

@@ -20,6 +20,22 @@ describe("model info helpers", () => {
 		assert.equal(findModelInfo("openai/gpt-5-mini:high", ambiguousModels, "github-copilot")?.fullId, "openai/gpt-5-mini");
 	});
 
+	it("matches owner/name registry ids without treating the owner as a provider", () => {
+		const hfModels: ModelInfo[] = [
+			{
+				provider: "huggingface",
+				id: "thinkingmachines/Inkling",
+				fullId: "huggingface/thinkingmachines/Inkling",
+				reasoning: true,
+			},
+		];
+		assert.equal(findModelInfo("thinkingmachines/Inkling", hfModels)?.fullId, "huggingface/thinkingmachines/Inkling");
+		assert.equal(
+			findModelInfo("huggingface/thinkingmachines/Inkling", hfModels)?.fullId,
+			"huggingface/thinkingmachines/Inkling",
+		);
+	});
+
 	it("preserves registry API metadata", () => {
 		assert.equal(toModelInfo({ provider: "gateway", id: "model", api: "anthropic-messages" }).api, "anthropic-messages");
 	});
@@ -82,3 +98,65 @@ describe("model info helpers", () => {
 		);
 	});
 });
+
+describe("toModelInfo registry fields", () => {
+	it("carries contextWindow, maxTokens, input, and cost from the registry", () => {
+		const info = toModelInfo({
+			provider: "openai",
+			id: "gpt-5-mini",
+			api: "openai-responses",
+			reasoning: true,
+			contextWindow: 272000,
+			maxTokens: 128000,
+			input: ["text", "image"],
+			cost: { input: 0.25, output: 2, cacheRead: 0.025, cacheWrite: 0.25 },
+		});
+		assert.equal(info.contextWindow, 272000);
+		assert.equal(info.maxTokens, 128000);
+		assert.deepEqual(info.input, ["text", "image"]);
+		assert.deepEqual(info.cost, { input: 0.25, output: 2, cacheRead: 0.025, cacheWrite: 0.25 });
+	});
+
+	it("omits fields the registry does not report", () => {
+		const info = toModelInfo({ provider: "local", id: "custom-model" });
+		assert.equal(info.fullId, "local/custom-model");
+		assert.equal("contextWindow" in info, false);
+		assert.equal("maxTokens" in info, false);
+		assert.equal("input" in info, false);
+		assert.equal("cost" in info, false);
+	});
+
+	it("ignores non-positive or malformed registry values", () => {
+		const info = toModelInfo({
+			provider: "local",
+			id: "broken",
+			contextWindow: 0,
+			maxTokens: -1,
+			input: [],
+			cost: { input: Number.NaN, output: 1 },
+		});
+		assert.equal("contextWindow" in info, false);
+		assert.equal("maxTokens" in info, false);
+		assert.equal("input" in info, false);
+		assert.equal("cost" in info, false);
+	});
+
+	it("copies the input array instead of aliasing the registry entry", () => {
+		const registryInput = ["text"];
+		const info = toModelInfo({ provider: "local", id: "m", input: registryInput });
+		assert.notEqual(info.input, registryInput);
+		assert.deepEqual(info.input, ["text"]);
+	});
+
+	it("preserves and copies tiered registry cost", () => {
+		const tiers = [{ inputTokensAbove: 100_000, input: 1, output: 2, cacheRead: 0.1, cacheWrite: 0.2 }];
+		const info = toModelInfo({
+			provider: "openai",
+			id: "tiered",
+			cost: { input: 0.5, output: 1, cacheRead: 0.05, cacheWrite: 0.1, tiers },
+		});
+		assert.deepEqual(info.cost?.tiers, tiers);
+		assert.notEqual(info.cost?.tiers, tiers);
+		assert.notEqual(info.cost?.tiers?.[0], tiers[0]);
+	});
+});