pi-crew 0.1.14 → 0.1.15

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.15
+
+- Child-process model selection now uses Pi-configured/available models and auto-discovers provider/model entries from Pi settings/models config.
+- Added configured-model fallback chains for worker runs instead of forcing builtin provider hints.
+- Fixed skipped task agent records so they no longer appear queued.
+
 ## 0.1.0
 
 - Initial scaffold for `pi-crew`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
   "author": "baphuongna",
   "license": "MIT",

package/src/extension/team-tool.ts

@@ -307,7 +307,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	const runtime = await resolveCrewRuntime(effectiveRunConfig(loadedConfig.config, params.config));
 	const executeWorkers = runtime.kind === "child-process";
 	const executedConfig = effectiveRunConfig(loadedConfig.config, params.config);
-	const executed = await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, signal: ctx.signal });
+	const executed = await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal: ctx.signal });
 	const text = [
 		`Created pi-crew run ${executed.manifest.runId}.`,
 		`Team: ${team.name}`,
@@ -430,7 +430,7 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 		const loadedConfig = loadConfig(ctx.cwd);
 		const runtime = await resolveCrewRuntime(loadedConfig.config);
 		const executeWorkers = runtime.kind === "child-process";
-		const executed = await executeTeamRun({ manifest: loaded.manifest, tasks: resetTasks, team, workflow, agents: allAgents(discoverAgents(ctx.cwd)), executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, signal: ctx.signal });
+		const executed = await executeTeamRun({ manifest: loaded.manifest, tasks: resetTasks, team, workflow, agents: allAgents(discoverAgents(ctx.cwd)), executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal: ctx.signal });
 		return result([`Resumed run ${executed.manifest.runId}.`, `Status: ${executed.manifest.status}`, `Tasks: ${executed.tasks.length}`, `Artifacts: ${executed.manifest.artifactsRoot}`].join("\n"), { action: "resume", status: executed.manifest.status === "failed" ? "error" : "ok", runId: executed.manifest.runId, artifactsRoot: executed.manifest.artifactsRoot }, executed.manifest.status === "failed");
 	});
 }

package/src/runtime/crew-agent-runtime.ts

@@ -48,7 +48,7 @@ export interface CrewAgentRecord {
 export function taskStatusToAgentStatus(status: TeamTaskStatus): CrewAgentStatus {
 	if (status === "completed") return "completed";
 	if (status === "failed") return "failed";
-	if (status === "cancelled") return "cancelled";
+	if (status === "cancelled" || status === "skipped") return "cancelled";
 	if (status === "running") return "running";
 	return "queued";
 }

package/src/runtime/model-fallback.ts

@@ -1,3 +1,7 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
 export interface AvailableModelInfo {
 	provider: string;
 	id: string;
@@ -11,6 +15,114 @@ export interface ModelAttemptSummary {
 	error?: string;
 }
 
+export interface ModelLike {
+	provider?: unknown;
+	id?: unknown;
+}
+
+export interface ModelRegistryLike {
+	getAvailable?: () => unknown[];
+	getAll?: () => unknown[];
+}
+
+interface PiSettingsLike {
+	defaultProvider?: unknown;
+	defaultModel?: unknown;
+}
+
+interface PiModelsJsonLike {
+	providers?: unknown;
+}
+
+interface PiProviderConfigLike {
+	models?: unknown;
+	modelOverrides?: unknown;
+}
+
+function modelInfoFromUnknown(value: unknown): AvailableModelInfo | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const record = value as ModelLike;
+	if (typeof record.provider !== "string" || typeof record.id !== "string") return undefined;
+	return { provider: record.provider, id: record.id, fullId: `${record.provider}/${record.id}` };
+}
+
+export function availableModelInfosFromRegistry(registry: unknown): AvailableModelInfo[] | undefined {
+	if (!registry || typeof registry !== "object" || Array.isArray(registry)) return undefined;
+	const candidate = registry as ModelRegistryLike;
+	const raw = typeof candidate.getAvailable === "function" ? candidate.getAvailable() : typeof candidate.getAll === "function" ? candidate.getAll() : undefined;
+	if (!Array.isArray(raw)) return undefined;
+	return raw.map(modelInfoFromUnknown).filter((entry): entry is AvailableModelInfo => entry !== undefined);
+}
+
+export function modelStringFromUnknown(model: unknown): string | undefined {
+	return modelInfoFromUnknown(model)?.fullId;
+}
+
+function uniqueModelInfos(models: AvailableModelInfo[]): AvailableModelInfo[] {
+	const seen = new Set<string>();
+	return models.filter((model) => {
+		if (seen.has(model.fullId)) return false;
+		seen.add(model.fullId);
+		return true;
+	});
+}
+
+function readJsonObject(filePath: string): Record<string, unknown> | undefined {
+	try {
+		if (!fs.existsSync(filePath)) return undefined;
+		const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as Record<string, unknown> : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function piAgentDir(): string {
+	const envDir = process.env.PI_CODING_AGENT_DIR?.trim();
+	if (envDir) {
+		if (envDir === "~") return os.homedir();
+		if (envDir.startsWith("~/")) return path.join(os.homedir(), envDir.slice(2));
+		return envDir;
+	}
+	return path.join(os.homedir(), ".pi", "agent");
+}
+
+function settingsModelInfo(settings: PiSettingsLike | undefined): AvailableModelInfo | undefined {
+	if (typeof settings?.defaultProvider !== "string" || typeof settings.defaultModel !== "string") return undefined;
+	return { provider: settings.defaultProvider, id: settings.defaultModel, fullId: `${settings.defaultProvider}/${settings.defaultModel}` };
+}
+
+function modelsJsonInfos(modelsJson: PiModelsJsonLike | undefined): AvailableModelInfo[] {
+	if (!modelsJson?.providers || typeof modelsJson.providers !== "object" || Array.isArray(modelsJson.providers)) return [];
+	const infos: AvailableModelInfo[] = [];
+	for (const [provider, rawConfig] of Object.entries(modelsJson.providers as Record<string, unknown>)) {
+		if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) continue;
+		const config = rawConfig as PiProviderConfigLike;
+		if (Array.isArray(config.models)) {
+			for (const rawModel of config.models) {
+				if (!rawModel || typeof rawModel !== "object" || Array.isArray(rawModel)) continue;
+				const id = (rawModel as { id?: unknown }).id;
+				if (typeof id === "string") infos.push({ provider, id, fullId: `${provider}/${id}` });
+			}
+		}
+		if (config.modelOverrides && typeof config.modelOverrides === "object" && !Array.isArray(config.modelOverrides)) {
+			for (const id of Object.keys(config.modelOverrides)) infos.push({ provider, id, fullId: `${provider}/${id}` });
+		}
+	}
+	return infos;
+}
+
+export function configuredModelInfosFromPiConfig(cwd?: string): AvailableModelInfo[] {
+	const agentDir = piAgentDir();
+	const globalSettings = readJsonObject(path.join(agentDir, "settings.json")) as PiSettingsLike | undefined;
+	const projectSettings = cwd ? readJsonObject(path.join(cwd, ".pi", "settings.json")) as PiSettingsLike | undefined : undefined;
+	const effectiveSettings = { ...(globalSettings ?? {}), ...(projectSettings ?? {}) };
+	return uniqueModelInfos([
+		...modelsJsonInfos(readJsonObject(path.join(agentDir, "models.json")) as PiModelsJsonLike | undefined),
+		...(settingsModelInfo(effectiveSettings) ? [settingsModelInfo(effectiveSettings)!] : []),
+	]);
+}
+
 export function splitThinkingSuffix(model: string): { baseModel: string; thinkingSuffix: string } {
 	const colonIdx = model.lastIndexOf(":");
 	if (colonIdx === -1) return { baseModel: model, thinkingSuffix: "" };
@@ -99,3 +211,34 @@ export function buildModelCandidates(
 	}
 	return candidates;
 }
+
+function isAvailableModel(model: string, availableModels: AvailableModelInfo[] | undefined): boolean {
+	if (!availableModels || availableModels.length === 0) return true;
+	const { baseModel } = splitThinkingSuffix(model);
+	if (baseModel.includes("/")) return availableModels.some((entry) => entry.fullId === baseModel);
+	return availableModels.some((entry) => entry.id === baseModel);
+}
+
+export function buildConfiguredModelCandidates(input: {
+	overrideModel?: string;
+	stepModel?: string;
+	agentModel?: string;
+	fallbackModels?: string[];
+	parentModel?: unknown;
+	modelRegistry?: unknown;
+	cwd?: string;
+}): string[] {
+	const registryModels = availableModelInfosFromRegistry(input.modelRegistry);
+	const configModels = configuredModelInfosFromPiConfig(input.cwd);
+	const availableModels = registryModels && registryModels.length > 0 ? registryModels : configModels.length > 0 ? configModels : registryModels;
+	const parentModel = modelStringFromUnknown(input.parentModel);
+	const preferredProvider = parentModel?.split("/")[0] ?? availableModels?.[0]?.provider;
+	if (availableModels && availableModels.length === 0) return [];
+	const rawModels = availableModels
+		? [input.overrideModel, input.stepModel, input.agentModel, ...(input.fallbackModels ?? []), parentModel, ...availableModels.map((model) => model.fullId)]
+		: [input.overrideModel, parentModel];
+	const configuredModels = rawModels
+		.filter((model): model is string => Boolean(model?.trim()))
+		.filter((model) => isAvailableModel(model.trim(), availableModels));
+	return buildModelCandidates(configuredModels[0], configuredModels.slice(1), availableModels, preferredProvider);
+}

package/src/runtime/task-runner.ts

@@ -9,7 +9,7 @@ import { createTaskClaim } from "../state/task-claims.ts";
 import { createWorkerHeartbeat, touchWorkerHeartbeat } from "./worker-heartbeat.ts";
 import type { WorkflowStep } from "../workflows/workflow-config.ts";
 import { captureWorktreeDiff, captureWorktreeDiffStat, prepareTaskWorkspace } from "../worktree/worktree-manager.ts";
-import { buildModelCandidates, formatModelAttemptNote, isRetryableModelFailure, type ModelAttemptSummary } from "./model-fallback.ts";
+import { buildConfiguredModelCandidates, formatModelAttemptNote, isRetryableModelFailure, type ModelAttemptSummary } from "./model-fallback.ts";
 import { parsePiJsonOutput, type ParsedPiJsonOutput } from "./pi-json-output.ts";
 import { runChildPi } from "./child-pi.ts";
 import { buildTaskPacket, renderTaskPacket } from "./task-packet.ts";
@@ -36,6 +36,7 @@ export interface TaskRunnerInput {
 	parentContext?: string;
 	parentModel?: unknown;
 	modelRegistry?: unknown;
+	modelOverride?: string;
 	limits?: CrewLimitsConfig;
 	dependencyContextText?: string;
 }
@@ -267,8 +268,8 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		producer: task.id,
 	});
 	if (runtimeKind === "child-process") {
-		const candidates = buildModelCandidates(input.step.model ?? input.agent.model, input.agent.fallbackModels, undefined);
-		const attemptModels = candidates.length > 0 ? candidates : [input.step.model ?? input.agent.model];
+		const candidates = buildConfiguredModelCandidates({ overrideModel: input.modelOverride, stepModel: input.step.model, agentModel: input.agent.model, fallbackModels: input.agent.fallbackModels, parentModel: input.parentModel, modelRegistry: input.modelRegistry, cwd: manifest.cwd });
+		const attemptModels = candidates.length > 0 ? candidates : [undefined];
 		const logs: string[] = [];
 		let finalStdout = "";
 		let finalStderr = "";

package/src/runtime/team-runner.ts

@@ -30,6 +30,7 @@ export interface ExecuteTeamRunInput {
 	parentContext?: string;
 	parentModel?: unknown;
 	modelRegistry?: unknown;
+	modelOverride?: string;
 	signal?: AbortSignal;
 }
 
@@ -179,7 +180,7 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 		const results = await Promise.all(readyBatch.map((task) => {
 			const step = findStep(input.workflow, task);
 			const agent = findAgent(input.agents, task);
-			return runTeamTask({ manifest, tasks, task, step, agent, signal: input.signal, executeWorkers: input.executeWorkers, runtimeKind: input.runtime?.kind, runtimeConfig: input.runtimeConfig, parentContext: input.parentContext, parentModel: input.parentModel, modelRegistry: input.modelRegistry, limits: input.limits });
+			return runTeamTask({ manifest, tasks, task, step, agent, signal: input.signal, executeWorkers: input.executeWorkers, runtimeKind: input.runtime?.kind, runtimeConfig: input.runtimeConfig, parentContext: input.parentContext, parentModel: input.parentModel, modelRegistry: input.modelRegistry, modelOverride: input.modelOverride, limits: input.limits });
 		}));
 		manifest = { ...results.at(-1)!.manifest, artifacts: mergeArtifacts([manifest.artifacts, ...results.map((item) => item.manifest.artifacts)].flat()) };
 		tasks = mergeTaskUpdates(tasks, results);