@henryqw/pi-subagent 2.3.5 → 2.4.0

package/README.md

@@ -21,7 +21,9 @@ pi install npm:@henryqw/pi-subagent
 
 | Surface | Type | Purpose |
 | --- | --- | --- |
-| `delegate_task` | tool | Start one isolated child for `role`, `task`, and optional `modelClass`. |
+| `delegate_task` | tool | Start one isolated child for `role`, `task`, and optional `model` or `modelClass`. |
+
+An explicit `model` (`provider/modelId`) overrides `modelClass` and resolves against the currently available text models; an unknown reference rejects with the list of available models. Thinking level defaults to `medium` when supported, otherwise the highest supported level.
 
 `modelClass` is `fast`, `balanced`, or `frontier`. Omitted class uses the shared `pi-subagent/delegateTask` assignment, which defaults to `balanced`. Primary route is resolved against current scoped text models; fallback is tried only before launch. If no route is usable, delegation rejects with `Run /task-models`. A started child is never retried.
 

package/extensions/subagent.ts

@@ -4,7 +4,15 @@ import { basename } from "node:path";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { type ExtensionAPI, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
 import { type Component, truncateToWidth, type TUI, visibleWidth } from "@earendil-works/pi-tui";
-import { modelReference, PROFILE_NAMES, type ProfileName } from "@henryqw/pi-task-models";
+import {
+	availableTaskModels,
+	modelReference,
+	PROFILE_NAMES,
+	type ProfileName,
+	resolveAvailableModel,
+	type ResolvedTaskRoute,
+	taskThinkingLevels,
+} from "@henryqw/pi-task-models";
 import { Type } from "typebox";
 import { createRoleLaunch, isProfileName, loadRoles, resolveRoleLaunch, resolveTaskRoute } from "@henryqw/pi-subagent";
 
@@ -415,11 +423,24 @@ const Parameters = Type.Object({
 	task: Type.String({
 		description: "Bounded task packet: objective; exact scope and exclusions; relevant context and constraints; expected deliverable; validation. Never the whole parent request.",
 	}),
+	model: Type.Optional(Type.String({
+		description: "Designated model as provider/modelId; overrides modelClass. Unknown references reject with the list of available models.",
+	})),
 	modelClass: Type.Optional(StringEnum(MODEL_CLASSES, {
 		description: "Classify task complexity: fast for narrow lookups or mechanical edits; balanced for normal bounded work; frontier for ambiguous, cross-cutting, or high-risk reasoning. Defaults to the shared pi-subagent/delegateTask assignment.",
 	})),
 });
 
+function resolveDesignatedRoute(ctx: ExtensionContext, reference: string): ResolvedTaskRoute {
+	const models = availableTaskModels(ctx);
+	const model = resolveAvailableModel(models, reference, ctx.model?.provider);
+	if (!model) {
+		throw new Error(`Unknown delegate_task model: ${reference}. Available models: ${models.map((candidate) => modelReference(candidate)).join(", ") || "none"}.`);
+	}
+	const levels = taskThinkingLevels(ctx, model);
+	return { model, thinkingLevel: levels.includes("medium") ? "medium" : levels.at(-1)! };
+}
+
 const roleSummary = (): string => {
 	try {
 		const roles = loadRoles();
@@ -553,7 +574,7 @@ export default function subagentExtension(
 	pi.registerTool({
 		name: "delegate_task",
 		label: "Subagent",
-		description: `Delegate one bounded, independently executable task to one isolated Pi Subagent. Roles: ${roleSummary()}. Choose fast for narrow work, balanced for normal work, or frontier for ambiguous and high-risk work; omit modelClass to use shared task-model settings.`,
+		description: `Delegate one bounded, independently executable task to one isolated Pi Subagent. Roles: ${roleSummary()}. Choose fast for narrow work, balanced for normal work, or frontier for ambiguous and high-risk work; omit modelClass to use shared task-model settings. When the user designates a specific model, pass it as provider/modelId in model.`,
 		promptSnippet: "Delegate one bounded, independently executable task to an isolated role",
 		promptGuidelines: [
 			"Before calling delegate_task, split broad work into the smallest independent bounded tasks; keep integration and cross-cutting decisions in Main.",
@@ -573,9 +594,11 @@ export default function subagentExtension(
 			if (params.modelClass !== undefined && !isModelClass(params.modelClass)) {
 				throw new Error("delegate_task modelClass must be fast, balanced, or frontier.");
 			}
-			const launch = params.modelClass === undefined
-				? resolveRoleLaunch(pi, ctx, { role, taskId: SUBAGENT_TASK })
-				: createRoleLaunch(pi, ctx, { role, route: resolveTaskRoute(ctx, params.modelClass) });
+			const launch = params.model !== undefined
+				? createRoleLaunch(pi, ctx, { role, route: resolveDesignatedRoute(ctx, cleanText(params.model, "model", "delegate_task")) })
+				: params.modelClass === undefined
+					? resolveRoleLaunch(pi, ctx, { role, taskId: SUBAGENT_TASK })
+					: createRoleLaunch(pi, ctx, { role, route: resolveTaskRoute(ctx, params.modelClass) });
 			const modelReferenceValue = modelReference(launch.model);
 			const thinkingLevel = launch.thinkingLevel;
 			if (launch.missingSkills.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-subagent",
-  "version": "2.3.5",
+  "version": "2.4.0",
   "description": "Delegate one task to an isolated Pi role with explicit extensions and skills.",
   "keywords": [
     "pi-package",