fix(pi): translate provider ids between canonical config and Pi's form

OpenCode and Pi now share one config, but a few auth-plugin providers are named
differently on each harness (the model id after the slash is identical):

  canonical (OpenCode)   Pi
  openai/<model>         openai-codex/<model>
  google/<model>         google-antigravity/<model>

A model picked on one harness was unusable on the other: a config holding the
canonical google/openai form (e.g. from OpenCode setup or hand-editing) made Pi's
historian/dreamer/sidekick fail to resolve the model.

Canonical = OpenCode; the shared config always stores the OpenCode form. Pi
translates at its two edges via a new shared map (harness-provider-map.ts):
- read: resolveModelRefForPi() at the single --model emit in subagent-runner
  buildArgs() — covers historian/dreamer/sidekick/recomp/fallbacks uniformly
  since every spawn routes through runner.run(). options.model stays canonical
  everywhere else (accounting, logging, fallback selection). Idempotent, so a
  config already in Pi form still works.
- write: piModelRefToCanonical() in the Pi setup wizard, so a config written
  from the Pi side stays OpenCode-readable.

OpenCode is untouched (canonical is its own form). Provider-prefix only; anthropic
and every other provider pass through unchanged.

Gate: Pi 519/0 (+map/buildArgs tests), CLI 207/0, map 8/0, tsc + biome clean.

Co-authored-by: Alfonso [Magic Context] <288211368+alfonso-magic-context@users.noreply.github.com>

Author: ualtinok

packages/cli/src/commands/setup-pi.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { dirname } from "node:path";
+import { piModelRefToCanonical } from "@magic-context/core/shared/harness-provider-map";
 import { parse as parseJsonc, stringify as stringifyJsonc } from "comment-json";
 import { writeFileAtomic } from "../lib/atomic-write";
 import {
@@ -151,14 +152,17 @@ export function writeMagicContextConfig(
             "https://raw.githubusercontent.com/cortexkit/magic-context/master/assets/magic-context.schema.json";
     }
 
+    // The Pi model picker yields Pi-native provider ids (openai-codex/...,
+    // google-antigravity/...). The shared config is canonical (OpenCode) form so
+    // OpenCode can read the same file; normalize before writing.
     config.historian = compactObject({
         ...((config.historian as Record<string, unknown> | undefined) ?? {}),
-        model: options.historianModel,
+        model: piModelRefToCanonical(options.historianModel),
         thinking_level: options.historianThinkingLevel,
     });
     const dreamer = {
         ...((config.dreamer as Record<string, unknown> | undefined) ?? {}),
-        model: options.dreamerModel,
+        model: options.dreamerModel ? piModelRefToCanonical(options.dreamerModel) : undefined,
         disable: options.dreamerEnabled ? undefined : true,
         enabled: undefined,
         // Dreamer v2 per-task schedules — only set when the user declined the
@@ -169,7 +173,10 @@ export function writeMagicContextConfig(
 
     const sidekick = {
         ...((config.sidekick as Record<string, unknown> | undefined) ?? {}),
-        model: options.sidekickEnabled ? options.sidekickModel : undefined,
+        model:
+            options.sidekickEnabled && options.sidekickModel
+                ? piModelRefToCanonical(options.sidekickModel)
+                : undefined,
         disable: options.sidekickEnabled ? undefined : true,
         enabled: undefined,
     };

packages/pi-plugin/src/subagent-runner.test.ts

@@ -182,6 +182,29 @@ describe("subagent-runner pure helpers", () => {
 		expect(args.at(-1)).toBe("summarize this session");
 	});
 
+	it("translates the canonical (OpenCode) provider to Pi's form at --model", () => {
+		// Shared config stores canonical ids; Pi names two auth-plugin providers
+		// differently. The spawned --model must carry Pi's form.
+		expect(
+			__test.buildArgs({ ...baseOptions, model: "openai/gpt-5.5" }),
+		).toEqual(expect.arrayContaining(["--model", "openai-codex/gpt-5.5"]));
+		expect(
+			__test.buildArgs({
+				...baseOptions,
+				model: "google/antigravity-gemini-3.5-flash",
+			}),
+		).toEqual(
+			expect.arrayContaining([
+				"--model",
+				"google-antigravity/antigravity-gemini-3.5-flash",
+			]),
+		);
+		// Anthropic and other providers pass through unchanged.
+		expect(
+			__test.buildArgs({ ...baseOptions, model: "anthropic/claude-opus-4-8" }),
+		).toEqual(expect.arrayContaining(["--model", "anthropic/claude-opus-4-8"]));
+	});
+
 	it("passes prompt last without a -- sentinel", () => {
 		const args = __test.buildArgs({
 			...baseOptions,
@@ -934,8 +957,10 @@ describe("PiSubagentRunner spawn lifecycle", () => {
 		expect(spawnImpl.mock.calls[0]?.[1]).toEqual(
 			expect.arrayContaining(["--model", "anthropic/primary"]),
 		);
+		// The canonical (OpenCode) `openai/` provider is translated to Pi's
+		// `openai-codex/` form at the spawn boundary.
 		expect(spawnImpl.mock.calls[1]?.[1]).toEqual(
-			expect.arrayContaining(["--model", "openai/fallback"]),
+			expect.arrayContaining(["--model", "openai-codex/fallback"]),
 		);
 	});
 

packages/pi-plugin/src/subagent-runner.ts

@@ -7,6 +7,7 @@ import { fileURLToPath } from "node:url";
 import { openDatabase } from "@magic-context/core/features/magic-context/storage";
 import type { SubagentKind } from "@magic-context/core/features/magic-context/storage-subagent-invocations";
 import { recordChildInvocation } from "@magic-context/core/features/magic-context/subagent-token-capture";
+import { resolveModelRefForPi } from "@magic-context/core/shared/harness-provider-map";
 import { sessionLog } from "@magic-context/core/shared/logger";
 import type {
 	SubagentProgressEvent,
@@ -1071,7 +1072,13 @@ export function buildArgs(
 		// Pi's --models flag scopes the model picker list; it is not an ordered
 		// fallback chain. The runner implements fallback by spawning a fresh child
 		// per model, so each invocation receives exactly one --model.
-		args.push("--model", options.model);
+		//
+		// The shared config stores the canonical (OpenCode) provider form; Pi
+		// names a few auth-plugin providers differently (openai->openai-codex,
+		// google->google-antigravity). Translate to Pi's form HERE, at the only
+		// point the model reaches the spawned process, so options.model stays
+		// canonical everywhere else (accounting, logging, fallback selection).
+		args.push("--model", resolveModelRefForPi(options.model));
 	}
 
 	// Pass --thinking <level> only when explicitly configured.

packages/plugin/src/shared/harness-provider-map.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "bun:test";
+import { piModelRefToCanonical, resolveModelRefForPi } from "./harness-provider-map";
+
+describe("harness-provider-map", () => {
+    describe("resolveModelRefForPi (canonical -> Pi, used when spawning)", () => {
+        it("maps the diverging auth-plugin providers, preserving the model id", () => {
+            expect(resolveModelRefForPi("openai/gpt-5.5")).toBe("openai-codex/gpt-5.5");
+            expect(resolveModelRefForPi("google/antigravity-gemini-3.5-flash")).toBe(
+                "google-antigravity/antigravity-gemini-3.5-flash",
+            );
+        });
+
+        it("leaves anthropic and every other provider unchanged", () => {
+            expect(resolveModelRefForPi("anthropic/claude-opus-4-8")).toBe(
+                "anthropic/claude-opus-4-8",
+            );
+            expect(resolveModelRefForPi("cerebras/gpt-oss-120b")).toBe("cerebras/gpt-oss-120b");
+            expect(resolveModelRefForPi("openrouter/openai/gpt-5.5")).toBe(
+                "openrouter/openai/gpt-5.5",
+            );
+        });
+
+        it("is idempotent: a config already in Pi form still resolves to Pi form", () => {
+            expect(resolveModelRefForPi("openai-codex/gpt-5.5")).toBe("openai-codex/gpt-5.5");
+            expect(resolveModelRefForPi("google-antigravity/antigravity-gemini-3.1-pro")).toBe(
+                "google-antigravity/antigravity-gemini-3.1-pro",
+            );
+        });
+
+        it("preserves model ids that themselves contain slashes", () => {
+            expect(resolveModelRefForPi("openai/some/nested/id")).toBe(
+                "openai-codex/some/nested/id",
+            );
+        });
+
+        it("passes through malformed refs (no slash, empty provider) unchanged", () => {
+            expect(resolveModelRefForPi("gpt-5.5")).toBe("gpt-5.5");
+            expect(resolveModelRefForPi("/gpt-5.5")).toBe("/gpt-5.5");
+            expect(resolveModelRefForPi("")).toBe("");
+        });
+    });
+
+    describe("piModelRefToCanonical (Pi -> canonical, used by Pi setup write)", () => {
+        it("normalizes Pi-native provider ids to the OpenCode form", () => {
+            expect(piModelRefToCanonical("openai-codex/gpt-5.5")).toBe("openai/gpt-5.5");
+            expect(piModelRefToCanonical("google-antigravity/antigravity-gemini-3.5-flash")).toBe(
+                "google/antigravity-gemini-3.5-flash",
+            );
+        });
+
+        it("leaves already-canonical and unmapped providers unchanged", () => {
+            expect(piModelRefToCanonical("anthropic/claude-opus-4-8")).toBe(
+                "anthropic/claude-opus-4-8",
+            );
+            expect(piModelRefToCanonical("openai/gpt-5.5")).toBe("openai/gpt-5.5");
+        });
+
+        it("round-trips with resolveModelRefForPi", () => {
+            const piForm = "openai-codex/gpt-5.5";
+            expect(resolveModelRefForPi(piModelRefToCanonical(piForm))).toBe(piForm);
+        });
+    });
+});

packages/plugin/src/shared/harness-provider-map.ts

@@ -0,0 +1,56 @@
+/**
+ * Provider-id translation between the canonical (OpenCode) form stored in the
+ * shared magic-context config and Pi's harness-native provider ids.
+ *
+ * OpenCode and Pi now share ONE config, but a few auth-plugin providers were
+ * named differently on each side. The model id AFTER the slash is identical;
+ * only the provider prefix differs:
+ *
+ *   canonical (OpenCode)   Pi
+ *   --------------------   -------------------
+ *   openai/<model>         openai-codex/<model>
+ *   google/<model>         google-antigravity/<model>
+ *   anthropic/<model>      anthropic/<model>      (same; every other provider too)
+ *
+ * Canonical = OpenCode: the config always stores the OpenCode form. Pi
+ * translates at its edges:
+ *   - read:  canonical -> Pi when spawning a configured model (subagent-runner).
+ *   - write: Pi -> canonical in the Pi setup wizard, so a config written from
+ *            the Pi side stays readable by OpenCode.
+ *
+ * OpenCode needs no translation (canonical IS the OpenCode form).
+ */
+
+const CANONICAL_TO_PI_PROVIDER: Record<string, string> = {
+    openai: "openai-codex",
+    google: "google-antigravity",
+};
+
+const PI_TO_CANONICAL_PROVIDER: Record<string, string> = {
+    "openai-codex": "openai",
+    "google-antigravity": "google",
+};
+
+/** Remap only the provider prefix (text before the first "/"), preserving the
+ *  model id verbatim. No "/", empty provider, or unmapped provider -> unchanged. */
+function remapProviderPrefix(ref: string, map: Record<string, string>): string {
+    if (typeof ref !== "string") return ref;
+    const slash = ref.indexOf("/");
+    if (slash <= 0) return ref;
+    const provider = ref.slice(0, slash);
+    const mapped = map[provider];
+    return mapped ? `${mapped}${ref.slice(slash)}` : ref;
+}
+
+/** Pi-native `provider/model` -> canonical (OpenCode). Identity when unmapped.
+ *  Used by the Pi setup wizard so configs it writes stay OpenCode-readable. */
+export function piModelRefToCanonical(ref: string): string {
+    return remapProviderPrefix(ref, PI_TO_CANONICAL_PROVIDER);
+}
+
+/** Canonical (OpenCode) `provider/model` -> Pi-native, for spawning a model on
+ *  Pi. Idempotent: normalizes any Pi-form prefix back to canonical first, so it
+ *  is safe on a config that already holds Pi-form ids (hand-edited or pre-fix). */
+export function resolveModelRefForPi(ref: string): string {
+    return remapProviderPrefix(piModelRefToCanonical(ref), CANONICAL_TO_PI_PROVIDER);
+}