@phi-code-admin/phi-code 0.76.11 → 0.76.12

package/extensions/phi/init.ts

@@ -196,13 +196,22 @@ async function detectLocalProviders(providers: DetectedProvider[]): Promise<void
 	);
 }
 
-function getAllAvailableModels(providers: DetectedProvider[]): string[] {
-	const ids = new Set<string>();
+function getAllAvailableModels(providers: DetectedProvider[]): Array<{ ref: string; display: string }> {
+	const out: Array<{ ref: string; display: string }> = [];
+	const seen = new Set<string>();
 	for (const p of providers) {
 		if (!p.available) continue;
-		for (const id of p.models) ids.add(id);
+		for (const id of p.models) {
+			// Provider-qualified reference ("provider/id") so the same model id
+			// offered by several providers stays distinct, and the provider is
+			// visible at selection. No cross-provider dedup (only exact dupes).
+			const ref = `${p.id}/${id}`;
+			if (seen.has(ref)) continue;
+			seen.add(ref);
+			out.push({ ref, display: `${id} [${p.id}]` });
+		}
 	}
-	return [...ids];
+	return out;
 }
 
 // ─── Routing Presets ─────────────────────────────────────────────────────
@@ -387,25 +396,32 @@ _Edit this file to customize Phi Code's behavior for your project._
 	// the user's `/model` choice on every routing decision.
 
 	async function manualMode(
-		availableModels: string[],
+		availableModels: Array<{ ref: string; display: string }>,
 		ctx: any,
 	): Promise<Record<string, { preferred: string; fallback: string }>> {
 		ctx.ui.notify(
 			"Assign a model to each orchestration role.\n" +
 				"These models are used by `/plan` and the orchestrator — NOT by normal chat.\n" +
-				"The chat default model is controlled via `/model` (and stays sticky across prompts).\n",
+				"The chat default model is controlled via `/model` (and stays sticky across prompts).\n" +
+				"Each option shows its provider as `model-id [provider]`, so the same model from\n" +
+				"different providers stays distinct.\n",
 			"info",
 		);
-		const modelOptions = ["default (use current chat model)", ...availableModels];
+		// Display strings carry the provider badge; map them back to the canonical
+		// "provider/id" reference that gets persisted into routing.json.
+		const DEFAULT_OPTION = "default (use current chat model)";
+		const refByDisplay = new Map<string, string>([[DEFAULT_OPTION, "default"]]);
+		for (const m of availableModels) refByDisplay.set(m.display, m.ref);
+		const modelOptions = [DEFAULT_OPTION, ...availableModels.map((m) => m.display)];
 		const assignments: Record<string, { preferred: string; fallback: string }> = {};
 
 		for (const role of TASK_ROLES) {
 			const chosen = await ctx.ui.select(`${role.label} — ${role.desc}`, modelOptions);
-			const preferredModel = chosen && chosen !== modelOptions[0] ? chosen : "default";
+			const preferredModel = refByDisplay.get(chosen) ?? "default";
 
 			const fallbackOptions = modelOptions.filter((m) => m !== chosen);
 			const fallbackChoice = await ctx.ui.select(`Fallback for ${role.label}`, fallbackOptions);
-			const fallback = fallbackChoice && fallbackChoice !== modelOptions[0] ? fallbackChoice : "default";
+			const fallback = refByDisplay.get(fallbackChoice) ?? "default";
 
 			assignments[role.key] = { preferred: preferredModel, fallback };
 			ctx.ui.notify(`  ${role.label}: ${preferredModel} (fallback: ${fallback})`, "info");
@@ -415,7 +431,7 @@ _Edit this file to customize Phi Code's behavior for your project._
 		// This is NOT the chat default — `/model` controls that.
 		assignments["default"] = {
 			preferred: "default",
-			fallback: availableModels[0] || "default",
+			fallback: availableModels[0]?.ref || "default",
 		};
 		return assignments;
 	}

package/extensions/phi/orchestrator.ts

@@ -561,16 +561,33 @@ Tag the note with relevant keywords for vector search.
 		];
 	}
 
+	/**
+	 * Resolve a routing.json model reference to an available model.
+	 * Accepts a provider-qualified "provider/id" reference (so the same model id
+	 * offered by several providers can be disambiguated) and falls back to a bare
+	 * "id" for legacy configs. Splits on the FIRST slash only, since some model
+	 * ids themselves contain slashes (e.g. OpenRouter "anthropic/claude-...").
+	 */
+	function resolveModelRef(available: any[], ref: string): any | undefined {
+		if (!ref) return undefined;
+		const slash = ref.indexOf("/");
+		if (slash > 0) {
+			const provider = ref.slice(0, slash);
+			const id = ref.slice(slash + 1);
+			const qualified = available.find((m: any) => m.provider === provider && m.id === id);
+			if (qualified) return qualified;
+		}
+		return available.find((m: any) => m.id === ref);
+	}
+
 	/**
 	 * Switch model for the current phase.
 	 */
 	async function switchModelForPhase(phase: OrchestratorPhase, ctx: any): Promise<string> {
 		const available = ctx.modelRegistry?.getAvailable?.() || [];
-		const preferred = available.find((m: any) => m.id === phase.model);
-		const fallback = available.find((m: any) => m.id === phase.fallback);
-		const target = preferred || fallback;
+		const target = resolveModelRef(available, phase.model) || resolveModelRef(available, phase.fallback);
 
-		if (target && target.id !== ctx.model?.id) {
+		if (target && (target.id !== ctx.model?.id || target.provider !== ctx.model?.provider)) {
 			const switched = await pi.setModel(target);
 			if (switched) return target.id;
 		}

package/extensions/phi/setup.ts

@@ -516,23 +516,25 @@ async function configureLocal(
 async function pickModelFromCatalog(
 	ui: ExtensionUIContext,
 	prompt: string,
-	allModelIds: string[],
+	models: Array<{ ref: string; display: string }>,
 ): Promise<string | undefined> {
-	if (allModelIds.length === 0) {
+	if (models.length === 0) {
 		ui.notify("No models available. Configure a provider first.", "warning");
 		return undefined;
 	}
-	const options = ["(keep default)", ...allModelIds];
+	const KEEP = "(keep default)";
+	const options = [KEEP, ...models.map((m) => m.display)];
 	const choice = await ui.select(prompt, options);
-	if (!choice || choice === options[0]) return undefined;
-	return choice;
+	if (!choice || choice === KEEP) return undefined;
+	// Map the displayed "id [provider]" back to the canonical "provider/id" ref.
+	return models.find((m) => m.display === choice)?.ref;
 }
 
 async function configureAssignments(
 	ui: ExtensionUIContext,
-	allModelIds: string[],
+	models: Array<{ ref: string; display: string }>,
 ): Promise<{ defaultModel: string; orchestration: Record<string, RouteAssignment> }> {
-	if (allModelIds.length === 0) {
+	if (models.length === 0) {
 		ui.notify("No models available for assignment. Configure a provider first.", "warning");
 		return { defaultModel: "default", orchestration: {} };
 	}
@@ -551,11 +553,11 @@ async function configureAssignments(
 	const orchestration: Record<string, RouteAssignment> = {};
 	for (const role of ORCHESTRATION_ROLES) {
 		const preferred =
-			(await pickModelFromCatalog(ui, `${role.label} - preferred model (${role.desc})`, allModelIds)) ??
-			allModelIds[0];
-		const fallbackOptions = allModelIds.filter((m) => m !== preferred);
-		const fallback = fallbackOptions.length > 0
-			? (await pickModelFromCatalog(ui, `${role.label} - fallback model`, fallbackOptions)) ?? preferred
+			(await pickModelFromCatalog(ui, `${role.label} - preferred model (${role.desc})`, models)) ??
+			models[0].ref;
+		const fallbackModels = models.filter((m) => m.ref !== preferred);
+		const fallback = fallbackModels.length > 0
+			? (await pickModelFromCatalog(ui, `${role.label} - fallback model`, fallbackModels)) ?? preferred
 			: preferred;
 		orchestration[role.key] = { preferred, fallback };
 		ui.notify(`  ${role.label}: ${preferred} / ${fallback}`, "info");
@@ -675,17 +677,23 @@ export default function setupExtension(pi: ExtensionAPI) {
 				}
 
 				if (action === "Assign models to agent roles") {
-					const allModelIds: string[] = [];
+					const allModels: Array<{ ref: string; display: string }> = [];
+					const seenRefs = new Set<string>();
 					for (const p of catalog) {
 						const stored = store.getProvider(p.id);
 						if (!stored) continue;
 						const models = Array.isArray(stored.models) ? stored.models : [];
 						for (const m of models) {
 							const id = (m as { id?: string }).id;
-							if (typeof id === "string" && !allModelIds.includes(id)) allModelIds.push(id);
+							if (typeof id !== "string") continue;
+							// Provider-qualified ref so the same id from different providers stays distinct.
+							const ref = `${p.id}/${id}`;
+							if (seenRefs.has(ref)) continue;
+							seenRefs.add(ref);
+							allModels.push({ ref, display: `${id} [${p.id}]` });
 						}
 					}
-					const { defaultModel, orchestration } = await configureAssignments(ui, allModelIds);
+					const { defaultModel, orchestration } = await configureAssignments(ui, allModels);
 					assignments.default = defaultModel;
 					assignments.orchestration = orchestration;
 					refreshAvailable();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@phi-code-admin/phi-code",
-	"version": "0.76.11",
+	"version": "0.76.12",
 	"description": "Coding agent CLI with persistent memory, sub-agents, intelligent routing, and orchestration",
 	"type": "module",
 	"piConfig": {