feat(provider): Meta sign-in vs API-key chooser + auto-copy device url

Author: TheGreatAxios

packages/first-class-providers/src/providers.test.ts

@@ -95,6 +95,26 @@ describe("FIRST_CLASS_PROVIDERS", () => {
     }
   });
 
+  test("Meta is a chooser with Sign In and API key paths", () => {
+    const meta = firstClassProviderById("meta");
+    expect(meta?.auth).toBe("chooser");
+    expect(meta?.paths?.map((p) => p.id)).toEqual(["signin", "api"]);
+
+    const signin = meta?.paths?.find((p) => p.id === "signin");
+    expect(signin?.auth).toBe("oauth");
+    expect(signin?.oauth).toBe("meta");
+    expect(signin?.providerId).toBe("meta");
+
+    const api = meta?.paths?.find((p) => p.id === "api");
+    expect(api?.auth).toBe("api-key");
+    expect(api?.providerId).toBe("meta");
+    expect(api?.baseURL).toBe("https://api.meta.ai/v1");
+    expect(api?.defaultModel).toBe("muse-spark-1.3");
+    expect((api?.models ?? []).length).toBeGreaterThan(0);
+    expect(api?.models).toContain(api?.defaultModel);
+    expect(api?.authHint).toContain("LLM|");
+  });
+
   test("API-key providers ship baseURL, models, and defaultModel", () => {
     for (const def of FIRST_CLASS_PROVIDERS) {
       if (def.auth !== "api-key") continue;

packages/first-class-providers/src/providers.ts

@@ -13,6 +13,7 @@ import {
   ZEN_MODEL_IDS,
   ZEN_PROVIDER_ID,
 } from "../../zen/src/index.js";
+import { META_BASE_URL, META_DEFAULT_MODELS } from "@corbits/meta-provider";
 import type { FirstClassProviderDef } from "./types.js";
 
 const OPENAI_API_MODELS = [
@@ -91,8 +92,26 @@ export const FIRST_CLASS_PROVIDERS: readonly FirstClassProviderDef[] = [
   {
     id: "meta",
     label: "Meta",
-    auth: "oauth",
-    oauth: "meta",
+    auth: "chooser",
+    paths: [
+      {
+        id: "signin",
+        label: "Sign In",
+        auth: "oauth",
+        oauth: "meta",
+        providerId: "meta",
+      },
+      {
+        id: "api",
+        label: "Meta API — API key",
+        auth: "api-key",
+        baseURL: META_BASE_URL,
+        models: META_DEFAULT_MODELS,
+        defaultModel: "muse-spark-1.3",
+        authHint: "Paste your Meta API key (LLM|...)",
+        providerId: "meta",
+      },
+    ],
   },
   {
     id: OPENCODE_GO_PROVIDER_ID,

src/config/index.ts

@@ -459,6 +459,32 @@ export function buildMetaSource(fields: {
   };
 }
 
+// Build the InferenceSource for a Meta Model API key (the Meta chooser's
+// "API key" path, a hand-named meta/<slug>, or a bare `meta` settings row).
+// The endpoint speaks the Responses protocol, so the source rides the same
+// "meta" adapter as the OAuth profiles — only the credential provenance
+// differs: a plain key is api-key provenance, never an OAuth profile.
+export function buildMetaApiKeySource(fields: {
+  id: string;
+  apiKey?: string;
+  model: string;
+  sessionId: string;
+  reasoningEffort?: ReasoningEffort;
+}): InferenceSource {
+  const providerOptions: Record<string, unknown> = {};
+  if (fields.reasoningEffort !== undefined)
+    providerOptions[META_REASONING_EFFORT_OPTION] = fields.reasoningEffort;
+  registerSourceSecret(fields.id, fields.apiKey);
+  return {
+    id: fields.id,
+    provider: META_PROVIDER,
+    baseURL: META_BASE_URL,
+    credentialId: fields.id,
+    model: fields.model,
+    defaults: { maxTokens: SOURCE_MAX_TOKENS, providerOptions },
+  };
+}
+
 // Build the InferenceSource for a Bifrost virtual-key provider. Routes to the
 // "bifrost" adapter (a thin openai-compatible wrapper) which injects the
 // x-bf-vk sentinel header.

src/config/inference-sources.test.ts

@@ -178,6 +178,57 @@ describe("source credential provenance", () => {
     });
   });
 
+  test("Meta API-key rows route to the meta-responses adapter, never chat completions", () => {
+    const source = buildInferenceSourceForRef(
+      { provider: "meta", model: "muse-spark-1.3" },
+      {
+        sessionId: "sess-meta-key",
+        catalog: [
+          {
+            name: "meta",
+            baseURL: "https://api.meta.ai/v1",
+            apiKey: "LLM|plain-key",
+            models: ["muse-spark-1.3"],
+          },
+        ],
+      },
+      undefined,
+    );
+
+    if (source === null) throw new Error("expected Meta API-key source");
+    expect(source.provider).toBe("meta");
+    expect(source.baseURL).toBe("https://api.meta.ai/v1");
+    expect(source.credentialId).toBe("meta");
+    expect(readSourceCredentialRecord(source.credentialId).provenance).toEqual({
+      kind: "api-key",
+    });
+  });
+
+  test("a namespaced Meta API-key row routes to the meta-responses adapter", () => {
+    const source = buildInferenceSourceForRef(
+      { provider: "meta/personal", model: "muse-spark-1.2" },
+      {
+        sessionId: "sess-meta-slug",
+        catalog: [
+          {
+            name: "meta/personal",
+            baseURL: "https://api.meta.ai/v1",
+            apiKey: "LLM|plain-key",
+            models: ["muse-spark-1.2"],
+          },
+        ],
+      },
+      undefined,
+    );
+
+    if (source === null) throw new Error("expected Meta API-key source");
+    expect(source.provider).toBe("meta");
+    expect(source.baseURL).toBe("https://api.meta.ai/v1");
+    expect(readSourceCredentialRecord(source.credentialId).provenance).toEqual({
+      kind: "api-key",
+    });
+  });
+
   test("namespaced API-key rows are not inferred as OAuth", () => {
     const source = buildInferenceSourceForRef(
       { provider: "codex/shadow", model: "relay-model" },

src/config/inference-sources.ts

@@ -4,6 +4,7 @@ import {
   buildBifrostSource,
   buildCodexSource,
   buildGoSource,
+  buildMetaApiKeySource,
   buildMetaSource,
   buildZenSource,
   buildAnthropicSource,
@@ -26,6 +27,7 @@ import {
 } from "../provider/reasoning-effort.js";
 import { isOpenCodeGoProvider } from "../../packages/opencode-go/src/index.js";
 import { isZenProvider } from "../../packages/zen/src/index.js";
+import { isMetaProviderName } from "./meta-providers.js";
 import { customReasoningSettings } from "./providers.js";
 
 export interface BuildSourceContext {
@@ -146,6 +148,27 @@ export function buildInferenceSourceForRef(
       ...(effort !== undefined ? { reasoningEffort: effort } : {}),
     });
   }
+  // Meta Model API key rows (the Meta chooser's "API key" path, a hand-named
+  // meta/<slug>, or a bare `meta` row) also speak the Responses protocol at
+  // META_BASE_URL — never the openai-compatible /chat/completions fallback
+  // below. They have no metaProfile marker, so route them to the same
+  // meta-responses adapter as the OAuth profiles.
+  if (
+    ref.provider === "meta" ||
+    (entry?.metaProfile === undefined && isMetaProviderName(ref.provider))
+  ) {
+    return buildMetaApiKeySource({
+      id: ref.provider,
+      ...(entry?.apiKey !== undefined
+        ? { apiKey: entry.apiKey }
+        : providerSettings?.apiKey !== undefined
+          ? { apiKey: providerSettings.apiKey }
+          : {}),
+      model: ref.model,
+      sessionId: ctx.sessionId,
+      ...(effort !== undefined ? { reasoningEffort: effort } : {}),
+    });
+  }
   if (
     isOpenCodeGoProvider({
       name: ref.provider,

src/tui/provider-setup.test.ts

@@ -98,6 +98,8 @@ function stagedLoginStarter(
   opts: {
     onStart?: (input: StagedLoginInput) => void;
     deniedStarts?: number;
+    /** Emit a device_code event via `notify` on the first start (Meta flow). */
+    emitDeviceCode?: boolean;
   } = {},
 ): {
   start: OAuthLoginStarter;
@@ -124,6 +126,13 @@ function stagedLoginStarter(
     start: async (input) => {
       events.starts.push(input);
       opts.onStart?.(input);
+      if (opts.emitDeviceCode === true && events.starts.length === 1) {
+        input.notify?.({
+          type: "device_code",
+          verificationUri: "https://auth.meta.com/device?code=ABCD-1234",
+          userCode: "ABCD-1234",
+        });
+      }
       input.signal.addEventListener("abort", () => {
         events.aborted = true;
       });
@@ -349,7 +358,9 @@ describe("provider setup pure helpers", () => {
       { name: "codex/default" },
     ]);
     expect(rows.map((r) => r.id)).toContain(CUSTOM_CHOICE_ID);
-    expect(rows.map((r) => r.id)).toEqual(choices.map((c) => c.id));
+    // Alt+A rows are keyed by the pick-list row id (two Meta rows stay
+    // distinct), which mirrors the onboarding list.
+    expect(rows.map((r) => r.id)).toEqual(choices.map((c) => c.rowId));
     const openai = rows.find((r) => r.id === "openai");
     const codex = rows.find((r) => r.id === "codex");
     const custom = rows.find((r) => r.id === CUSTOM_CHOICE_ID);
@@ -485,6 +496,21 @@ async function mountConfig(
   return { done, harness };
 }
 
+/** Recording clipboard port for the Meta device-flow copy test. */
+function recordingClipboard(): {
+  clipboard: { writeText: (t: string) => void; writes: string[] };
+} {
+  const writes: string[] = [];
+  return {
+    clipboard: {
+      writes,
+      writeText: (text: string) => {
+        writes.push(text);
+      },
+    },
+  };
+}
+
 async function mountSetup(
   onSubmit: ProviderSetupSubmit = async () => undefined,
   showTelemetryNotice = false,
@@ -597,6 +623,7 @@ async function mountLogin(opts: {
   onSubmit?: ProviderSetupSubmit;
   loginTimeoutMs?: number;
   listOAuthProfiles?: OAuthProfileLister;
+  clipboard?: ProviderSetupConfig["clipboard"];
 }): Promise<{ done: Promise<boolean>; harness: Harness }> {
   return mountConfig({
     onSubmit: opts.onSubmit ?? (async () => undefined),
@@ -605,6 +632,7 @@ async function mountLogin(opts: {
     ...(opts.loginTimeoutMs !== undefined
       ? { loginTimeoutMs: opts.loginTimeoutMs }
       : {}),
+    ...(opts.clipboard !== undefined ? { clipboard: opts.clipboard } : {}),
   });
 }
 
@@ -1189,6 +1217,60 @@ describe("runProviderSetup sign-in", () => {
     harness.pressKey("Ctrl+C");
     expect(await done).toBe(false);
   });
+
+  test("the Meta device flow copies the verification URI to the clipboard", async () => {
+    const rec = recordingClipboard();
+    const { start } = stagedLoginStarter({ emitDeviceCode: true });
+    const { done, harness } = await mountLogin({
+      start,
+      clipboard: rec.clipboard,
+    });
+    await pickRow(harness, PROVIDER_IDS, "meta");
+    await nameOAuthAccount(harness);
+    const frame = harness.captureCharFrame();
+    expect(frame).toContain("https://auth.meta.com/device?code=ABCD-1234");
+    expect(frame).toContain("ABCD-1234");
+    expect(rec.clipboard.writes).toEqual([
+      "https://auth.meta.com/device?code=ABCD-1234",
+    ]);
+    harness.pressKey("Ctrl+C");
+    expect(await done).toBe(false);
+  });
+
+  test("the Meta chooser exposes two arrow-navigable rows with distinct ids", () => {
+    const metaRows = providerChoiceRows(providerChoices()).filter((r) =>
+      r.label.includes("Meta"),
+    );
+    expect(metaRows.map((r) => r.id)).toEqual(["meta", "meta/api"]);
+    expect(providerChoiceById("meta")?.oauth).toBe("meta");
+    expect(providerChoiceById("meta/api")?.oauth).toBeNull();
+    expect(providerChoiceById("meta/api")?.baseURL).toBe(
+      "https://api.meta.ai/v1",
+    );
+    expect(providerChoiceById("meta/api")?.defaultModel).toBe("muse-spark-1.3");
+  });
+
+  test("picking the Meta API-key row walks the key path, not the sign-in", async () => {
+    const seen: ProviderFormValues[] = [];
+    const { done, harness } = await mountSetup(async (values) => {
+      seen.push({ ...values });
+    });
+    await pickRow(harness, PROVIDER_IDS, "meta/api");
+    await flush(harness);
+    expect(harness.captureCharFrame()).toContain("step 2 of 4");
+    // Instance name step, then key — not the login step.
+    harness.pressKey("Enter");
+    await harness.renderOnce();
+    type(harness, "LLM|test-key");
+    harness.pressKey("Enter");
+    await harness.renderOnce();
+    harness.pressKey("Enter");
+    await harness.renderOnce();
+    expect(await done).toBe(true);
+    expect(seen[0]?.name).toBe("meta/default");
+    expect(seen[0]?.apiKey).toBe("LLM|test-key");
+    expect(seen[0]?.model).toBe("muse-spark-1.3");
+  });
 });
 
 describe("runProviderSetup", () => {