@audiofool/moondog 0.2.0-beta.6 → 0.2.0

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); };
+}