@audiofool/moondog 0.2.0-beta.7 → 0.2.1

package/src/runtime/pi/model-settings.mjs

@@ -6,15 +6,22 @@ import {
   createPiAuthentication,
   supportedAuthProviderIds,
 } from "./authentication.mjs";
+import { isEndpointProvider, removeEndpoint, saveEndpoint } from "./custom-endpoints.mjs";
+import { LEGACY_MODEL_ALIASES } from "./model-catalog.mjs";
+import { readConversationModels, readModelList, sameModel, writeConversationModel, writeModelList } from "./model-list.mjs";
+import { chatgptProviderId } from "./provider-registry.mjs";
 import { createPersistentCredentialStore } from "./persistent-credential-store.mjs";
 import { getPublicPiModelCatalog } from "./public-model-catalog.mjs";
-import { readPiRuntimeSelection } from "./runtime-settings.mjs";
+import { clampEffort, readPiRuntimeSelection } from "./runtime-settings.mjs";
 
 // The desktop window picks models and signs in through this service, as the
 // terminal does with /model and /auth. It returns status shapes only: never a
 // credential, a prompt answer or raw provider text.
 
-const OAUTH_PROVIDER = "openai-codex";
+// The providers every listener is offered, in this order: OpenAI by a ChatGPT subscription or an API
+// key, then Anthropic, Google and xAI. Any other service is reached as an endpoint by address; Pi's
+// other providers show only once a key for one is saved or in the environment.
+const FEATURED = ["openai", "anthropic", "google", "xai"];
 // Moondog's own errors carry fixed text. Pi wraps them, and its own text may not be safe.
 const moondogErrorNames = new Set(["MoondogCredentialStoreError", "MoondogRuntimeSettingsError"]);
 
@@ -33,7 +40,7 @@ function moondogError(error) {
 const aborted = () => new DOMException("The sign-in was cancelled.", "AbortError");
 
 function signInKind(providerId) {
-  if (providerId === OAUTH_PROVIDER) return "oauth";
+  if (isEndpointProvider(providerId)) return "endpoint";
   return supportedAuthProviderIds.includes(providerId) ? "api_key" : "environment_only";
 }
 
@@ -88,25 +95,23 @@ export function createModelSettings({
     }
   };
 
-  // The same list as the terminal's /model picker: providers with models, the
-  // current one first, then ChatGPT sign-in, then by name.
-  const listed = (source, currentProvider) => source.providers()
-    .filter(provider => provider.modelCount > 0)
-    .sort((left, right) => {
-      const priority = provider => provider.id === currentProvider ? 0 : provider.id === OAUTH_PROVIDER ? 1 : 2;
-      return priority(left) - priority(right) || left.name.localeCompare(right.name);
-    });
+  const listed = (source) => source.providers().filter(provider => provider.modelCount > 0);
+  const withAuth = (source) => source.createModels({
+    credentials: createPersistentCredentialStore(environment),
+    authContext: createPiAuthContext(environment),
+  });
 
   const rows = async (source, providers) => {
     try {
-      const models = source.createModels({
-        credentials: createPersistentCredentialStore(environment),
-        authContext: createPiAuthContext(environment),
-      });
+      const models = withAuth(source);
       return await Promise.all(providers.map(async ({ id, name, modelCount }) => {
         // checkAuth reads only local state. It never refreshes OAuth or calls a provider.
         const auth = await models.checkAuth(id);
-        return { id, name, modelCount, signIn: signInKind(id), signedIn: Boolean(auth), source: signInSource(auth) };
+        const endpoint = source.endpoints?.find(entry => entry.id === id);
+        // OpenAI takes a ChatGPT sign-in as well as a key; method says which one it has.
+        return { id, name, modelCount, signIn: signInKind(id), signedIn: Boolean(auth), source: signInSource(auth),
+          ...(id === chatgptProviderId ? { chatgpt: true } : {}), ...(auth ? { method: auth.type === "oauth" ? "oauth" : "api_key" } : {}),
+          ...(endpoint ? { endpoint: { format: endpoint.format, baseUrl: endpoint.baseUrl, keySaved: Boolean(endpoint.key), models: [...endpoint.models] } } : {}) };
       }));
     } catch (error) {
       throw moondogError(error) ?? failure("auth_status_failed", "Moondog could not read its saved sign-ins.");
@@ -118,6 +123,20 @@ export function createModelSettings({
     return (await rows(source, listed(source).filter(provider => provider.id === providerId)))[0];
   };
 
+  // The models the window's menu offers: the saved list, or the default alone until the listener
+  // changes it. The default is always among them.
+  const menu = async (selection) => {
+    let entries;
+    try {
+      entries = await readModelList(environment);
+    } catch (error) {
+      throw moondogError(error) ?? failure("model_list_invalid", "Moondog could not read its model list.");
+    }
+    entries ??= [];
+    if (selection && !entries.some(entry => sameModel(entry, selection))) entries = [{ provider: selection.provider, model: selection.model }, ...entries];
+    return entries;
+  };
+
   const assertSignInProvider = (providerId) => {
     if (!supportedAuthProviderIds.includes(providerId)) {
       throw failure("auth_provider_unsupported", "Moondog can't save a sign-in for this provider. Set its API key in the environment instead.");
@@ -127,10 +146,101 @@ export function createModelSettings({
   return {
     current,
 
+    // Settings' providers: the featured ones in their order, then any other provider that has a key or
+    // is in use, by name, then the listener's endpoints in the order they were added.
     async providers({ current: currentProvider } = {}) {
       currentProvider ??= (await current().catch(() => null))?.provider;
       const source = await catalog();
-      return rows(source, listed(source, currentProvider));
+      const all = await rows(source, listed(source));
+      const featured = FEATURED.map(id => all.find(provider => provider.id === id)).filter(Boolean);
+      const others = all.filter(provider => !FEATURED.includes(provider.id) && provider.signIn !== "endpoint" &&
+        (provider.signedIn || provider.id === currentProvider)).sort((left, right) => left.name.localeCompare(right.name));
+      const endpoints = (source.endpoints ?? []).map(endpoint => all.find(provider => provider.id === endpoint.id)).filter(Boolean);
+      return [...featured, ...others, ...endpoints];
+    },
+
+    // The menu's models, each with its provider's name and whether it can answer now, and the default
+    // with the thinking level it asks for and the one its model gets.
+    async list() {
+      const selection = await current();
+      const source = await catalog();
+      const entries = await menu(selection);
+      let models;
+      try {
+        models = withAuth(source);
+      } catch (error) {
+        throw moondogError(error) ?? failure("auth_status_failed", "Moondog could not read its saved sign-ins.");
+      }
+      const names = new Map(source.providers().map(provider => [provider.id, provider.name]));
+      const ready = new Map();
+      for (const provider of new Set(entries.map(entry => entry.provider))) {
+        ready.set(provider, Boolean(await models.checkAuth(provider).catch(() => undefined)));
+      }
+      const thinks = model => Boolean(model) && getSupportedThinkingLevels(model).length > 1;
+      const defaultModel = selection && models.getModel(selection.provider, selection.model);
+      return {
+        models: entries.map(entry => {
+          const model = models.getModel(entry.provider, entry.model);
+          return { provider: entry.provider, model: entry.model, name: model?.name ?? entry.model,
+            providerName: names.get(entry.provider) ?? entry.provider, ready: Boolean(model) && ready.get(entry.provider) === true,
+            reasoning: thinks(model) };
+        }),
+        default: selection ? { provider: selection.provider, model: selection.model, effort: selection.effort ?? null,
+          reasoning: thinks(defaultModel), thinking: selection.effort && defaultModel ? clampEffort(defaultModel, selection.effort) : null } : null,
+      };
+    },
+
+    // The model each conversation was given in the window's menu, and a change to one: null gives a
+    // conversation back to the default.
+    conversationModels: () => readConversationModels(environment),
+    setConversationModel: (session, selection) => writeConversationModel(String(session), selection ?? null, environment),
+
+    // Adds a model to the menu or takes it off. The default stays.
+    async setListed(provider, model, listed) {
+      const selection = await current();
+      const entry = { provider: String(provider ?? "").trim().toLowerCase(), model: String(model ?? "").trim() };
+      if (!listed && sameModel(entry, selection)) return;
+      const entries = await menu(selection);
+      const next = listed ? (entries.some(kept => sameModel(kept, entry)) ? entries : [...entries, entry])
+        : entries.filter(kept => !sameModel(kept, entry));
+      try {
+        await writeModelList(next, environment);
+      } catch (error) {
+        throw moondogError(error) ?? failure("model_list_invalid", "Moondog could not save its model list.");
+      }
+    },
+
+    // A new endpoint whose model IDs were typed goes straight into the menu with them; listed ones
+    // wait to be chosen, since an endpoint such as OpenRouter lists hundreds.
+    async saveEndpoint(input) {
+      let saved;
+      try {
+        saved = await saveEndpoint(input, environment);
+      } catch (error) {
+        throw moondogError(error) ?? failure("endpoint_save_failed", "Moondog could not save that endpoint.");
+      }
+      if (!input?.id && saved.typedModels) {
+        const entries = await menu(await current());
+        const added = saved.endpoint.models.map(model => ({ provider: saved.endpoint.id, model }));
+        await writeModelList([...entries, ...added.filter(entry => !entries.some(kept => sameModel(kept, entry)))].slice(0, 40), environment);
+      }
+      await (await catalog()).readEndpoints?.();
+      return saved.endpoint;
+    },
+
+    // Removes an endpoint, its key and its models from the menu. A default on it stays saved, and asks
+    // for another model until one is chosen.
+    async removeEndpoint(id) {
+      try {
+        await removeEndpoint(id, environment);
+      } catch (error) {
+        throw moondogError(error) ?? failure("endpoint_remove_failed", "Moondog could not remove that endpoint.");
+      }
+      const selection = await current();
+      const entries = await menu(null);
+      const kept = entries.filter(entry => entry.provider !== id || sameModel(entry, selection));
+      if (kept.length !== entries.length) await writeModelList(kept, environment);
+      await (await catalog()).readEndpoints?.();
     },
 
     async models(providerId, { force = false, signal } = {}) {
@@ -150,7 +260,7 @@ export function createModelSettings({
       return {
         provider: providerId,
         refresh,
-        models: source.models(providerId).map(({ id, name, contextWindow, reasoning, catalogNote }) => {
+        models: source.models(providerId).filter(({ id }) => !LEGACY_MODEL_ALIASES.includes(id)).map(({ id, name, contextWindow, reasoning, catalogNote }) => {
           const model = full.getModel(providerId, id);
           return { id, name, ...(contextWindow ? { contextWindow } : {}), reasoning,
             effortLevels: model ? getSupportedThinkingLevels(model) : [],
@@ -159,7 +269,8 @@ export function createModelSettings({
       };
     },
 
-    async signIn(providerId, interaction) {
+    // method "oauth" signs in to OpenAI with ChatGPT; anything else asks for a key.
+    async signIn(providerId, interaction, { method } = {}) {
       assertSignInProvider(providerId);
       if (typeof interaction?.prompt !== "function" || typeof interaction.notify !== "function") {
         throw failure("auth_interaction_invalid", "Sign-in needs a way to ask and to show progress.");
@@ -180,7 +291,7 @@ export function createModelSettings({
             if (!shape) return;
             try { interaction.notify(shape); } catch { /* A closed window cannot stop the sign-in. */ }
           },
-        });
+        }, { method: method === "oauth" ? "oauth" : "api_key" });
       } catch (error) {
         const safe = wrapLoginError(signal?.aborted ? aborted() : moondogError(error) ?? error, providerId);
         throw failure(safe.code, safe.message);

package/src/runtime/pi/model-transport.mjs

@@ -25,7 +25,7 @@ export function safeProviderErrorMessage(value, provider) {
   const message = typeof value === "string" && value.trim()
     ? value.trim() : "The model provider request failed.";
   if (credentialBearingErrorPattern.test(message)) {
-    return `${provider === "openai-codex" ? "OpenAI Codex" : provider} authentication failed. Run moondog auth login ${provider} and try again.`;
+    return `${provider === "openai" ? "OpenAI" : provider} authentication failed. Run moondog auth login ${provider}${provider === "openai" ? " --chatgpt, or with an API key," : ""} and try again.`;
   }
   return message;
 }
@@ -66,7 +66,7 @@ export function isModelConnectionFailure(value) {
 
 export function createModelConnectionError({ provider, cause, toolsExecuted = false }) {
   const label = ({
-    "openai-codex": "OpenAI Codex", openai: "OpenAI", anthropic: "Anthropic",
+    openai: "OpenAI", anthropic: "Anthropic",
     deepseek: "DeepSeek", moonshotai: "Moonshot AI", "moonshotai-cn": "Moonshot AI China",
     xai: "xAI", zai: "Z.AI",
   })[provider] ?? (/^[a-z0-9][a-z0-9._-]{0,63}$/iu.test(provider ?? "") ? provider : "The model provider");

package/src/runtime/pi/persistent-credential-store.mjs

@@ -21,6 +21,7 @@ const LOCK_TIMEOUT_MS = 30_000;
 // API keys for services other than models, such as Brave Search for web lookups.
 export const serviceApiKeyIds = Object.freeze(["brave"]);
 const apiKeyProviderIds = Object.freeze([...apiKeyPiProviderIds, ...serviceApiKeyIds]);
+// openai-codex is no longer offered, but a store that still holds its sign-in keeps loading.
 const SUPPORTED_CREDENTIAL_PROVIDERS = new Set([
   "openai-codex",
   "spotify",
@@ -105,6 +106,33 @@ function validateOpenAICodexCredential(value) {
   return structuredClone(value);
 }
 
+// Sign in with ChatGPT, through Pi's OpenAI provider: a token for api.openai.com and its refresh.
+function validateOpenAIChatGPTCredential(value) {
+  assertPlainRecord(value, "openai credential");
+  assertExactKeys(
+    value,
+    ["access", "clientId", "expires", "refresh", "type", ...(value.scopes === undefined ? [] : ["scopes"])],
+    "openai credential shape",
+  );
+  assertSecretString(value.access, "OAuth access token");
+  assertSecretString(value.refresh, "OAuth refresh token");
+  assertSecretString(value.clientId, "OAuth client identifier");
+  if (!Number.isFinite(value.expires) || value.expires <= 0) {
+    throw safeError(
+      "credential_store_corrupt",
+      "Moondog credential storage contains an invalid OAuth expiry.",
+    );
+  }
+  if (value.scopes !== undefined && (!Array.isArray(value.scopes) || value.scopes.length > 50 ||
+      value.scopes.some((scope) => typeof scope !== "string" || !/^[\x21-\x7e]{1,200}$/u.test(scope)))) {
+    throw safeError(
+      "credential_store_corrupt",
+      "Moondog credential storage contains invalid OAuth scopes.",
+    );
+  }
+  return structuredClone(value);
+}
+
 function validateSpotifyCredential(value) {
   assertPlainRecord(value, "spotify credential");
   assertExactKeys(
@@ -173,6 +201,9 @@ function validateCredential(providerId, value) {
   if (providerId === "spotify") {
     return validateSpotifyCredential(value);
   }
+  if (providerId === "openai" && value?.type === "oauth") {
+    return validateOpenAIChatGPTCredential(value);
+  }
   if (apiKeyProviderIds.includes(providerId)) {
     assertPlainRecord(value, `${providerId} credential`);
     assertExactKeys(value, ["type", "key"], `${providerId} credential shape`);

package/src/runtime/pi/provider-registry.mjs

@@ -35,12 +35,6 @@ const providerLoaders = {
     );
     return openaiProvider();
   },
-  "openai-codex": async () => {
-    const { openaiCodexProvider } = await import(
-      "@earendil-works/pi-ai/providers/openai-codex"
-    );
-    return openaiCodexProvider();
-  },
   openrouter: async () => {
     const { openrouterProvider } = await import(
       "@earendil-works/pi-ai/providers/openrouter"
@@ -63,9 +57,9 @@ export const supportedPiProviderIds = Object.freeze(
   Object.keys(providerLoaders),
 );
 
-export const apiKeyPiProviderIds = Object.freeze(
-  supportedPiProviderIds.filter((providerId) => providerId !== "openai-codex"),
-);
+// Every provider takes a key; OpenAI also takes Sign in with ChatGPT.
+export const apiKeyPiProviderIds = supportedPiProviderIds;
+export const chatgptProviderId = "openai";
 
 export async function loadPiProvider(providerId) {
   if (!Object.hasOwn(providerLoaders, providerId)) return undefined;

package/src/runtime/pi/public-model-catalog.mjs

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
 import { lstat, mkdir, open, rename, unlink } from "node:fs/promises";
 import path from "node:path";
+import { addEndpoints, readEndpoints } from "./custom-endpoints.mjs";
 import { createPiModels, listPiModels, listPiProviders } from "./model-catalog.mjs";
 import { acquirePrivateFileLock, resolveMoondogAuthFile } from "./persistent-credential-store.mjs";
 import { supportedPiProviderIds } from "./provider-registry.mjs";
@@ -159,15 +160,21 @@ async function writeCache(root, file, document, signal) {
 export class PublicPiModelCatalog {
   constructor({ environment = process.env, fetchImpl = globalThis.fetch, now = Date.now, timeoutMs = 4000 } = {}) {
     this.root = path.join(path.dirname(resolveMoondogAuthFile(environment)), "model-catalog");
+    this.environment = environment;
     this.fetch = fetchImpl; this.now = now; this.timeoutMs = timeoutMs;
-    this.baseline = createPiModels(); this.records = new Map(); this.pending = new Set();
+    this.baseline = createPiModels(); this.records = new Map(); this.pending = new Set(); this.endpoints = [];
     this.snapshot = this.baseline;
     this.ready = this.restore();
   }
 
   file(id) { return path.join(this.root, `${id}.json`); }
   publish() { this.snapshot = this.createModels(); }
-  createModels(options) { return createPiModels({ ...options, catalogModels: new Map([...this.records].map(([id, record]) => [id, record.models])) }); }
+  // The listener's own endpoints join Pi's providers; their models are theirs, not from pi.dev.
+  createModels(options) { return addEndpoints(createPiModels({ ...options, catalogModels: new Map([...this.records].map(([id, record]) => [id, record.models])) }), this.endpoints); }
+  async readEndpoints() {
+    try { this.endpoints = await readEndpoints(this.environment); } catch { this.endpoints = []; }
+    this.publish();
+  }
   providers() { return listPiProviders(this.snapshot); }
   models(id) {
     const record = this.records.get(id);
@@ -277,12 +284,13 @@ export async function getPublicPiModelCatalog(environment = process.env) {
   const key = path.dirname(resolveMoondogAuthFile(environment));
   if (!catalogs.has(key)) {
     const catalog = new PublicPiModelCatalog({ environment });
-    catalogs.set(key, catalog); await catalog.ready; return catalog;
+    catalogs.set(key, catalog); await catalog.ready; await catalog.readEndpoints(); return catalog;
   }
   const catalog = catalogs.get(key);
   await catalog.ready;
-  // Another running app can persist a new selection and its catalog entry.
+  // Another running app can persist a new selection, its catalog entry or an endpoint.
   // Reload public cache only; do not fetch or touch the active model object.
   await catalog.restore();
+  await catalog.readEndpoints();
   return catalog;
 }

package/src/runtime/pi/runtime-selection.mjs

@@ -0,0 +1,9 @@
+// Whether an agent built earlier is behind the saved choice: another model or effort, or an agent
+// that could not answer then, which a sign-in since may let answer. Token refreshes rewrite
+// auth.json often, so a working agent on the saved model is kept. Kept apart from the settings
+// file, so the window code the project page runs in the browser can use it.
+export function runtimeBehindSelection(status, selection) {
+  if (status?.state !== "configured") return true;
+  return status.provider !== selection?.provider || status.model !== selection?.model ||
+    (status.effort ?? undefined) !== selection?.effort;
+}

package/src/runtime/pi/runtime-settings.mjs

@@ -1,11 +1,27 @@
+import { unwatchFile, watchFile } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 
+import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+
 import { resolveMoondogAuthFile } from "./persistent-credential-store.mjs";
 
 const SETTINGS_VERSION = 1;
 // Pi's thinking levels. Each model supports a subset; the runtime clamps to it.
 export const EFFORT_LEVELS = Object.freeze(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+// The scale the window and /effort offer for every model that thinks.
+export const EFFORT_SCALE = Object.freeze(["off", "low", "medium", "high", "xhigh", "max"]);
+
+// A level the model lacks steps down to the nearest one it has, so a choice never costs more than it
+// said, but never down to no thinking; with nothing below, it takes the lightest level the model has.
+export function clampEffort(model, level) {
+  const supported = getSupportedThinkingLevels(model);
+  if (supported.includes(level)) return level;
+  const at = EFFORT_LEVELS.indexOf(level);
+  for (let index = at - 1; index > 0; index -= 1) if (supported.includes(EFFORT_LEVELS[index])) return EFFORT_LEVELS[index];
+  for (let index = Math.max(at + 1, 1); index < EFFORT_LEVELS.length; index += 1) if (supported.includes(EFFORT_LEVELS[index])) return EFFORT_LEVELS[index];
+  return supported[0] ?? "off";
+}
 
 function settingsError(message, cause) {
   const error = new Error(message, cause ? { cause } : undefined);
@@ -87,3 +103,24 @@ export async function writePiRuntimeSelection(
   );
   return normalized;
 }
+
+// The terminal and the window each build their agent from settings.json and auth.json. A model
+// chosen, or a sign-in made, on one side reaches the other through this watch. onChange hears the
+// saved selection, or undefined when none is saved; the surface decides whether to rebuild, with
+// runtimeBehindSelection.
+// The second argument says which file changed: "settings" (the default), "auth" (a sign-in),
+// "endpoints" (an endpoint added, edited or removed) or "models" (the window's menu list).
+export function watchRuntimeSettings({ environment = process.env, interval = 2000, onChange } = {}) {
+  const directory = path.dirname(resolveMoondogAuthFile(environment));
+  const files = { settings: resolveMoondogSettingsFile(environment), auth: resolveMoondogAuthFile(environment),
+    endpoints: path.join(directory, "endpoints.json"), models: path.join(directory, "models.json") };
+  const listeners = Object.entries(files).map(([changed, file]) => {
+    const listener = (now, before) => {
+      if (now.mtimeMs === before.mtimeMs) return;
+      void readPiRuntimeSelection(environment).then((selection) => onChange?.(selection, changed), () => {});
+    };
+    watchFile(file, { interval, persistent: false }, listener);
+    return [file, listener];
+  });
+  return () => { for (const [file, listener] of listeners) unwatchFile(file, listener); };
+}

package/src/surfaces/cli/auth-command.mjs

@@ -8,22 +8,22 @@ import {
 } from "../../runtime/pi/authentication.mjs";
 import { sanitizeTerminalText } from "./format-output.mjs";
 
-const DEFAULT_AUTH_PROVIDER = "openai-codex";
+const DEFAULT_AUTH_PROVIDER = "openai";
 
 export function authHelpText() {
   return `# Moondog authentication
 
 Commands:
 
-- \`moondog auth login openai-codex\` - start a browser OAuth login
-- \`moondog auth login openai-codex --device-code\` - use headless device login
+- \`moondog auth login openai --chatgpt\` - sign in with your ChatGPT subscription in the browser
 - \`moondog auth login <provider>\` - save an API key using hidden terminal input
 - \`moondog auth status [provider] [--json]\` - inspect saved or environment credentials
 - \`moondog auth logout <provider> [--json]\` - remove that provider's saved credential
 
-API key providers: ${supportedAuthProviderIds.filter((id) => id !== DEFAULT_AUTH_PROVIDER && !serviceKeyProviders.some((service) => service.id === id)).join(", ")}.
+API key providers: ${supportedAuthProviderIds.filter((id) => !serviceKeyProviders.some((service) => service.id === id)).join(", ")}.
 Web search keys: ${serviceKeyProviders.map((service) => `${service.id} for ${service.name} (or ${service.variable})`).join(", ")}; a deepseek key also searches and reads pages.
-Use zai for GLM, moonshotai or moonshotai-cn for Kimi, xai for Grok, openai for GPT, and anthropic for Claude.
+Use openai for GPT, anthropic for Claude, google for Gemini, xai for Grok, zai for GLM, and moonshotai or moonshotai-cn for Kimi.
+OpenAI takes either a ChatGPT sign-in or an API key; the newer one replaces the other.
 Moondog keeps credentials in its own private local store.
 API keys are entered interactively, never as command arguments.
 It does not read, modify, or log out the Codex CLI or ChatGPT desktop session.`;
@@ -39,19 +39,11 @@ function parseAuthArguments(args) {
       action: "help",
       provider: undefined,
       extra: [],
-      loginMethod: "browser",
+      chatgpt: false,
     };
   }
-  const deviceCodeIndex = values.indexOf("--device-code");
-  const browserIndex = values.indexOf("--browser");
-  const deviceCode = deviceCodeIndex !== -1;
-  const browser = browserIndex !== -1;
-  if (deviceCode) values.splice(deviceCodeIndex, 1);
-  const adjustedBrowserIndex = values.indexOf("--browser");
-  if (adjustedBrowserIndex !== -1) values.splice(adjustedBrowserIndex, 1);
-  if (deviceCode && browser) {
-    throw new Error("Choose either --browser or --device-code, not both.");
-  }
+  const chatgptIndex = values.indexOf("--chatgpt");
+  if (chatgptIndex !== -1) values.splice(chatgptIndex, 1);
   const unknownOption = values.find((value) => value.startsWith("-"));
   if (unknownOption) {
     throw new Error(
@@ -62,7 +54,7 @@ function parseAuthArguments(args) {
     action: values[0],
     provider: values[1],
     extra: values.slice(2),
-    loginMethod: deviceCode ? "device_code" : "browser",
+    chatgpt: chatgptIndex !== -1,
   };
 }
 
@@ -80,7 +72,8 @@ function formatStatus(value) {
   return `${value.provider}: not configured`;
 }
 
-function createReadlineOutput(output) {
+// A readline output that can go quiet, so a key typed into it is never echoed.
+export function createReadlineOutput(output) {
   let muted = false;
   const stream = new Writable({
     write(chunk, encoding, callback) {
@@ -105,7 +98,6 @@ function createReadlineOutput(output) {
 function createAuthInteraction({
   input,
   output,
-  loginMethod,
   signal,
   interactive,
   apiKeyLogin,
@@ -126,15 +118,9 @@ function createAuthInteraction({
       signal,
       async prompt(prompt) {
         if (prompt.type === "select") {
-          const selected = prompt.options.find(
-            (option) => option.id === loginMethod,
+          throw new Error(
+            "The installed Pi provider asked for a login choice Moondog doesn't offer.",
           );
-          if (!selected) {
-            throw new Error(
-              "The installed Pi provider does not support the requested login method.",
-            );
-          }
-          return selected.id;
         }
         if (prompt.type === "secret" && !interactive) {
           throw new Error(
@@ -175,12 +161,6 @@ function createAuthInteraction({
             writeLine(output, event.url);
             if (event.instructions) writeLine(output, event.instructions);
             break;
-          case "device_code":
-            writeLine(output);
-            writeLine(output, "Open this URL to sign in with ChatGPT:");
-            writeLine(output, event.verificationUri);
-            writeLine(output, `Device code: ${event.userCode}`);
-            break;
           case "info":
             writeLine(output, event.message);
             for (const link of event.links ?? []) {
@@ -202,7 +182,7 @@ function createAuthInteraction({
 // Pi's login errors can carry provider response bodies. Every surface that signs
 // in shows only these fixed messages and codes.
 export function wrapLoginError(error, provider) {
-  const name = provider === DEFAULT_AUTH_PROVIDER ? "OpenAI Codex" : provider;
+  const name = provider === DEFAULT_AUTH_PROVIDER ? "OpenAI" : provider;
   if (error?.name === "AbortError" || error?.code === "ABORT_ERR") {
     const cancelled = new Error(`${name} login was cancelled.`);
     cancelled.code = "auth_login_cancelled";
@@ -248,11 +228,8 @@ export async function runAuthCommand({
   if (!["login", "status", "logout"].includes(options.action)) {
     throw new Error("Unknown auth command. Use login, status, logout, or help.");
   }
-  if (
-    options.action !== "login" &&
-    (options.loginMethod !== "browser" || args.includes("--browser"))
-  ) {
-    throw new Error("Login method options are valid only for auth login.");
+  if (options.action !== "login" && options.chatgpt) {
+    throw new Error("--chatgpt is valid only for auth login.");
   }
 
   const provider = options.provider ??
@@ -265,15 +242,10 @@ export async function runAuthCommand({
       `Unsupported auth provider. Choose ${supportedAuthProviderIds.join(", ")}.`,
     );
   }
-  const apiKeyLogin = provider !== DEFAULT_AUTH_PROVIDER;
-  if (
-    apiKeyLogin &&
-    (args.includes("--device-code") || args.includes("--browser"))
-  ) {
-    throw new Error(
-      "Browser and device-code options apply only to openai-codex OAuth login.",
-    );
+  if (options.chatgpt && provider !== DEFAULT_AUTH_PROVIDER) {
+    throw new Error("Only openai signs in with ChatGPT; other providers take an API key.");
   }
+  const apiKeyLogin = !options.chatgpt;
 
   if (options.action === "status") {
     const authentication = await createAuthentication({ environment });
@@ -299,9 +271,7 @@ export async function runAuthCommand({
       writeLine(output, formatStatus(status));
       writeLine(
         output,
-        apiKeyLogin
-          ? "Moondog's saved API key was removed. Environment credentials remain available until unset."
-          : "Moondog's local credential was removed. Codex CLI and ChatGPT desktop login were not changed.",
+        "Moondog's saved credential was removed. Environment credentials remain available until unset; the Codex CLI and ChatGPT desktop sign-ins were not changed.",
       );
     }
     return;
@@ -315,9 +285,9 @@ export async function runAuthCommand({
       "API key login requires an interactive terminal with hidden input. For headless use, set the provider's API key environment variable.",
     );
   }
-  if (!apiKeyLogin && options.loginMethod === "browser" && !interactive) {
+  if (!apiKeyLogin && !interactive) {
     throw new Error(
-      "Browser OAuth login requires an interactive terminal. Use --device-code for a headless session.",
+      "ChatGPT sign-in requires an interactive terminal. For headless use, set OPENAI_API_KEY instead.",
     );
   }
 
@@ -328,7 +298,6 @@ export async function runAuthCommand({
   const login = createAuthInteraction({
     input,
     output: progressOutput,
-    loginMethod: options.loginMethod,
     signal: controller.signal,
     interactive,
     apiKeyLogin,
@@ -336,7 +305,7 @@ export async function runAuthCommand({
   try {
     let status;
     try {
-      status = await authentication.login(provider, login.interaction);
+      status = await authentication.login(provider, login.interaction, { method: apiKeyLogin ? "api_key" : "oauth" });
     } catch (error) {
       throw wrapLoginError(error, provider);
     }
@@ -352,8 +321,8 @@ export async function runAuthCommand({
       : "Next, return to Moondog and run /model.");
     if (!apiKeyLogin) {
       writeLine(output, "For a non-interactive launch, use environment overrides:");
-      writeLine(output, "  export MOONDOG_PROVIDER=openai-codex");
-      writeLine(output, "  export MOONDOG_MODEL=gpt-5.6-terra");
+      writeLine(output, "  export MOONDOG_PROVIDER=openai");
+      writeLine(output, "  export MOONDOG_MODEL=gpt-6.1-sol");
       writeLine(output, "  moondog");
     }
   } finally {

package/src/surfaces/cli/brand-components.mjs

@@ -564,5 +564,5 @@ function wrapDescription(text, width) {
 }
 
 export function listeningHelp() {
-  return tr("# Your listening room\n\n## 01 / Listen and discover\n\nJust type to talk about music, ask for a playlist, or go exploring.\nTo talk, Moondog needs a model: `/auth` signs you in, then `/model` picks one.\nWhile an answer is coming, each step shows in the conversation, and the footer names the one in progress.\n\n- `/taste` - your profile: open any song or artist to see why it's there\n- `/taste report` - the whole picture on one page\n- `/import` - bring in your history, your library, or a playlist\n- `/lyrics` - the lyrics on the sleeve; `/lyrics sync` finds more\n- `/spotify` - play, queue, and make playlists in Spotify\n- Ask to move playback onto your iPhone, computer, or another Spotify device by name\n- `/web search <query>` or `/web read <url>` - look things up on public music sites\n\n## 02 / Make it yours\n\n- `/profile` - the same profile as `/taste`\n- `/profile corrections` - everything you've told me\n- `/profile retract <id>` - undo one of those\n- `/profile help` - the full set of profile commands\n- `/remember <text>`, `/memory`, `/forget <id>` - what I remember between conversations\n\n## 03 / Around the room\n\n- `/home` - back to the record sleeve; the conversation stays\n- `/theme paper|charcoal|terminal|auto` - change the look\n- `/art braille|ascii|off` - change the artwork\n- `/motion on|off` - turn the animation on or off\n- `/commands` or Ctrl+P - search every command; your message stays put\n- Page Up and Page Down scroll the conversation. The header and your draft stay put\n- Up and Down in the draft recall what you typed in this conversation\n- `/resume` - pick up a saved conversation (type to filter, Enter opens)\n- `/new` - start fresh; this conversation stays saved\n- `/status`, `/sources`, `/tools`, `/doctor` - see what's connected and working\n- `/reload` - reload model settings and sign-ins\n- `/update [--check] [--channel latest|beta]` - check for a release, or close this room and install it\n- `/help all` - every command, including the ones for the shell\n- `/language` - choose the language Moondog uses\n- `/quit` - leave\n\nTab moves to the menu on the home screen. Esc goes back to typing.\nEnter sends, and Shift+Enter starts a new line.\nTab or Enter accepts a suggestion.\nCtrl+C stops a model or web request, or leaves when nothing is running.\nIn the profile, type to filter, Tab switches lists, and Enter shows what you can do.\nCtrl+R refreshes it and Ctrl+O opens the full report.\nYour profile works without a model.\nPut quotes around paths, titles, and names that have spaces.");
+  return tr("# Your listening room\n\n## 01 / Listen and discover\n\nJust type to talk about music, ask for a playlist, or go exploring.\nTo talk, Moondog needs a model: `/auth` signs you in, then `/model` picks one.\nWhile an answer is coming, each step shows in the conversation, and the footer names the one in progress.\n\n- `/taste` - your profile: open any song or artist to see why it's there\n- `/taste report` - the whole picture on one page\n- `/import` - bring in your history, your library, or a playlist\n- `/lyrics` - the lyrics on the sleeve; `/lyrics sync` finds more\n- `/service` - choose where I play music: Spotify, Apple Music, or NetEase\n- `/spotify` - play, queue, and make playlists in Spotify\n- Ask to move playback onto your iPhone, computer, or another Spotify device by name\n- `/web search <query>` or `/web read <url>` - look things up on public music sites\n\n## 02 / Make it yours\n\n- `/profile` - the same profile as `/taste`\n- `/profile corrections` - everything you've told me\n- `/profile retract <id>` - undo one of those\n- `/profile help` - the full set of profile commands\n- `/remember <text>`, `/memory`, `/forget <id>` - what I remember between conversations\n\n## 03 / Around the room\n\n- `/home` - back to the record sleeve; the conversation stays\n- `/theme paper|charcoal|terminal|auto` - change the look\n- `/art braille|ascii|off` - change the artwork\n- `/motion on|off` - turn the animation on or off\n- `/commands` or Ctrl+P - search every command; your message stays put\n- Page Up and Page Down scroll the conversation. The header and your draft stay put\n- Up and Down in the draft recall what you typed in this conversation\n- `/resume` - pick up a saved conversation (type to filter, Enter opens)\n- `/new` - start fresh; this conversation stays saved\n- `/status`, `/sources`, `/tools`, `/doctor` - see what's connected and working\n- `/reload` - reload model settings and sign-ins\n- `/update [--check] [--channel latest|beta]` - check for a release, or close this room and install it\n- `/help all` - every command, including the ones for the shell\n- `/language` - choose the language Moondog uses\n- `/quit` - leave\n\nTab moves to the menu on the home screen. Esc goes back to typing.\nEnter sends, and Shift+Enter starts a new line.\nTab or Enter accepts a suggestion.\nCtrl+C stops a model or web request, or leaves when nothing is running.\nIn the profile, type to filter, Tab switches lists, and Enter shows what you can do.\nCtrl+R refreshes it and Ctrl+O opens the full report.\nYour profile works without a model.\nPut quotes around paths, titles, and names that have spaces.");
 }