@fastagent-sh/fastagent 0.24.0 → 0.24.1

package/dist/engines/pi/agent-session-factory.js

@@ -10,6 +10,7 @@ import { getCurrentSystemMessage } from "@earendil-works/pi-ai";
 import { resolveModel } from "./config.js";
 import { activePath, resolveSessionSettings } from "./session-settings.js";
 import { DEFAULT_THINKING_LEVEL, withModelRegistration } from "./models.js";
+import { registerAccountModels } from "./openai-account-models.js";
 import { agentSessionManager, sessionToolActivation, turnContext } from "./tool-context.js";
 /** fastagent's tools as pi tool definitions, bound to ONE session. */
 function toolDefinitions(tools, bound, sessionId) {
@@ -275,6 +276,10 @@ export async function definitionServices(options) {
             }),
             extensionsOverride: admissionFirst,
         },
+    }).then((services) => {
+        // AFTER the extensions: one that re-registers `openai` replaced the account-catalog wrapper.
+        registerAccountModels(modelRuntime);
+        return services;
     }));
     reportExtensionDiagnostics(services);
     return services;

package/dist/engines/pi/models.js

@@ -13,9 +13,13 @@ import { ModelRuntime } from "@earendil-works/pi-coding-agent";
 import { AGENT_MODEL_CATALOG_FILE, AGENT_MODELS_FILE, globalHome, resolveOverridePath } from "../../paths.js";
 import { writeFileAtomic } from "../../atomic-write.js";
 import { withLockedFile } from "./locked-file.js";
+import { OPENAI_PROVIDER, registerAccountModels, withAccountModels } from "./openai-account-models.js";
 /** The built-ins plus `providers` (a same id replaces a built-in), over any credential store. */
 export function piModelsOver(credentials, providers = []) {
     const models = builtinModels({ credentials, authContext: defaultProviderAuthContext() });
+    const openai = models.getProvider(OPENAI_PROVIDER);
+    if (openai)
+        models.setProvider(withAccountModels(openai));
     for (const provider of providers)
         models.setProvider(provider);
     return models;
@@ -281,6 +285,8 @@ export async function machineModelRuntime(options = {}) {
     const error = runtime.getError();
     if (error)
         throw new Error(error);
+    // A machine catalog refresh may refresh an OAuth token, which must carry the account's catalog over.
+    await withModelRegistration(runtime, async () => registerAccountModels(runtime));
     return runtime;
 }
 /** How long a catalog refresh may take, as `pi update --models` allows. */
@@ -383,6 +389,7 @@ export async function createPiModelRuntime(options) {
         throw new Error(`${error}${origin}`);
     }
     await withModelRegistration(runtime, async () => {
+        registerAccountModels(runtime);
         for (const provider of options.providers ?? [])
             runtime.registerNativeProvider(provider);
     });

package/dist/engines/pi/open.d.ts

@@ -101,9 +101,12 @@ export declare function assembleFront(front: AgentAssembly, extra?: {
  * `models.json`, and what its `extensions/` declare) filtered to the providers whose credentials are configured. The
  * directory needs no model set, and the same placement and credential layers as the opener apply, so a listed spec
  * authenticates there. Configuration is checked, not validity: no OAuth token is refreshed and no provider is called.
+ * A Sign in with ChatGPT on `openai` lists the account's own models (openai-account-models.ts), not pi's built-ins.
  *
  * `warn` reaches the credential store. An unreadable or corrupt credentials file otherwise reads as "nothing
- * configured", so a client that must not show that as an empty list passes a sink that throws.
+ * configured", so a client that must not show that as an empty list passes a sink that throws. A ChatGPT sign-in that
+ * carries no catalog is a normal, recoverable state (signed in before the catalog was read), not that: it is logged,
+ * never sent to `warn`, so a throwing sink does not fail the whole listing for it.
  */
 export declare function availableModelsFromDir(dir: string, options?: FastagentAuthOptions & CredentialSourceOptions): Promise<ModelDescriptor[]>;
 /**

package/dist/engines/pi/open.js

@@ -17,6 +17,8 @@ import { reportFindingsIfChanged } from "./report.js";
 import { readMachine, withMachine } from "./machine.js";
 import { createPiModelRuntime, globalCatalogPath, machineModelRuntime, refreshCatalog } from "./models.js";
 import { agentModels } from "./agent-models.js";
+import { OPENAI_PROVIDER, missingAccountModels } from "./openai-account-models.js";
+import { log } from "../../log.js";
 import { piSessionRecordStore } from "./session-store.js";
 import { gateSecrets } from "../../secrets-gate.js";
 /**
@@ -126,14 +128,21 @@ export function assembleFront(front, extra = {}) {
  * `models.json`, and what its `extensions/` declare) filtered to the providers whose credentials are configured. The
  * directory needs no model set, and the same placement and credential layers as the opener apply, so a listed spec
  * authenticates there. Configuration is checked, not validity: no OAuth token is refreshed and no provider is called.
+ * A Sign in with ChatGPT on `openai` lists the account's own models (openai-account-models.ts), not pi's built-ins.
  *
  * `warn` reaches the credential store. An unreadable or corrupt credentials file otherwise reads as "nothing
- * configured", so a client that must not show that as an empty list passes a sink that throws.
+ * configured", so a client that must not show that as an empty list passes a sink that throws. A ChatGPT sign-in that
+ * carries no catalog is a normal, recoverable state (signed in before the catalog was read), not that: it is logged,
+ * never sent to `warn`, so a throwing sink does not fail the whole listing for it.
  */
 export async function availableModelsFromDir(dir, options = {}) {
     const { agentDir, workspace } = resolvePlacement(dir);
-    const models = await agentModels(agentDir, options, { cwd: workspace }).runtime();
-    return describeModels(await models.getAvailable());
+    const environment = agentModels(agentDir, options, { cwd: workspace });
+    const available = await (await environment.runtime()).getAvailable();
+    const missing = missingAccountModels(await environment.credentials.read(OPENAI_PROVIDER));
+    if (missing)
+        log.warn(missing);
+    return describeModels(available);
 }
 /**
  * Refresh the agent's model catalog (`<agent dir>/models-store.json`) with the credentials

package/dist/engines/pi/openai-account-models.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The models a Sign in with ChatGPT can run on the `openai` provider: the ACCOUNT's catalog, which OpenAI publishes at
+ * `GET /v1/models` for the same access token, not pi's built-in list (most of which such an account is refused).
+ *
+ * pi lists a provider's models through `filterModels`, which is synchronous, so the catalog is read when there is a
+ * token to read it with (login and every token refresh) and kept on the credential, like the account it belongs to:
+ * a new account brings its own list, and nothing per-account lands in the definition's model catalog. pi's `openai`
+ * provider does not do this itself (checked against pi 0.99.2), so {@link withAccountModels} wraps it. An API key on the same
+ * provider keeps the built-in list.
+ */
+import type { Credential, Provider } from "@earendil-works/pi-ai";
+import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
+export declare const OPENAI_PROVIDER = "openai";
+/**
+ * Why the stored `openai` credential lists no models, when that is because its sign-in carries no catalog: the one
+ * wording a listing reports instead of falling back to every built-in model.
+ */
+export declare function missingAccountModels(credential: Credential | undefined): string | undefined;
+/**
+ * `provider` with the account catalog: read at login and at each token refresh, and the only models a ChatGPT
+ * sign-in lists. Anything without OAuth is returned as is.
+ */
+export declare function withAccountModels(provider: Provider): Provider;
+/**
+ * Put {@link withAccountModels} on a runtime's `openai`, over the provider the runtime composed (pi's remote catalog,
+ * the agent's models.json, and an extension's `registerProvider("openai", …)` included), so none of them is lost. pi
+ * composes a native provider with models.json once more; that second pass is idempotent today, and
+ * openai-account-models.test.ts holds it to that. Call it inside `withModelRegistration`, and again after extensions
+ * load: pi's `registerProvider` drops a native provider, and a refresh without the wrapper would store a credential
+ * without its catalog. Repeating it is harmless.
+ *
+ * Known ceiling: an extension that registers `openai` later than its load (from an event handler) drops the wrapper
+ * for that runtime.
+ */
+export declare function registerAccountModels(runtime: ModelRuntime): void;

package/dist/engines/pi/openai-account-models.js

@@ -0,0 +1,116 @@
+import { log } from "../../log.js";
+export const OPENAI_PROVIDER = "openai";
+const ACCOUNT_MODELS_URL = "https://api.openai.com/v1/models";
+/** Where the catalog is kept on the stored credential: the model ids the account lists, in OpenAI's order. */
+const ACCOUNT_MODELS_FIELD = "accountModels";
+/** A token refresh is bounded at 15s by pi; the catalog read must leave it room to finish and be stored. */
+const CATALOG_TIMEOUT_MS = 5_000;
+/** The slugs the account lists for a picker (`visibility: "list"`), in the server's order. */
+async function fetchAccountModels(access, signal) {
+    const timeout = AbortSignal.timeout(CATALOG_TIMEOUT_MS);
+    const response = await fetch(ACCOUNT_MODELS_URL, {
+        headers: { accept: "application/json", authorization: `Bearer ${access}` },
+        signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+    });
+    if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new Error(`GET ${ACCOUNT_MODELS_URL} answered ${response.status}: ${body || response.statusText}`);
+    }
+    const models = (await response.json())?.models;
+    if (!Array.isArray(models))
+        throw new Error(`GET ${ACCOUNT_MODELS_URL} answered without a "models" array`);
+    return models.flatMap((entry) => entry?.visibility === "list" && typeof entry.slug === "string" ? [entry.slug] : []);
+}
+/** The catalog a ChatGPT sign-in carries, or undefined when it carries none (signed in before it was read). */
+function accountModels(credential) {
+    const ids = credential[ACCOUNT_MODELS_FIELD];
+    return Array.isArray(ids) && ids.every((id) => typeof id === "string") ? ids : undefined;
+}
+/**
+ * Why the stored `openai` credential lists no models, when that is because its sign-in carries no catalog: the one
+ * wording a listing reports instead of falling back to every built-in model.
+ */
+export function missingAccountModels(credential) {
+    if (credential?.type !== "oauth" || accountModels(credential))
+        return undefined;
+    return ("[fastagent] the ChatGPT sign-in for openai carries no model catalog, so it lists no models: it is read at " +
+        "login and on each token refresh. Run `fastagent login` to read it now");
+}
+/**
+ * `provider` with the account catalog: read at login and at each token refresh, and the only models a ChatGPT
+ * sign-in lists. Anything without OAuth is returned as is.
+ */
+export function withAccountModels(provider) {
+    const oauth = provider.auth.oauth;
+    if (!oauth)
+        return provider;
+    const wrapped = {
+        ...oauth,
+        async login(interaction, options) {
+            const credential = await oauth.login(interaction, options);
+            try {
+                return {
+                    ...credential,
+                    [ACCOUNT_MODELS_FIELD]: await fetchAccountModels(credential.access, interaction.signal),
+                };
+            }
+            catch (error) {
+                // The sign-in itself worked and inference needs nothing more: keep it, and say the list is empty until the
+                // next token refresh reads the catalog.
+                interaction.notify({
+                    type: "info",
+                    message: `could not read this ChatGPT account's model catalog (${error.message}); it lists no models until the next token refresh or login`,
+                });
+                return credential;
+            }
+        },
+        async refresh(credential, signal) {
+            const next = await oauth.refresh(credential, signal);
+            try {
+                return { ...next, [ACCOUNT_MODELS_FIELD]: await fetchAccountModels(next.access, signal) };
+            }
+            catch (error) {
+                // NEVER fail here: the refresh token was just rotated, and a throw would leave the new one unstored and the
+                // old one spent. The previous catalog stands.
+                log.warn(`[fastagent] could not refresh the ChatGPT account's model catalog: ${error.message}`);
+                const previous = accountModels(credential);
+                return previous ? { ...next, [ACCOUNT_MODELS_FIELD]: previous } : next;
+            }
+        },
+    };
+    return {
+        ...provider,
+        auth: { ...provider.auth, oauth: wrapped },
+        filterModels: (models, credential) => {
+            const base = provider.filterModels?.(models, credential) ?? models;
+            if (credential?.type !== "oauth")
+                return base;
+            const listed = new Set(accountModels(credential) ?? []);
+            return base.filter((model) => listed.has(model.id));
+        },
+    };
+}
+/** Providers this module built, so a second registration leaves them as they are instead of wrapping them again. */
+const wrappedProviders = new WeakSet();
+/**
+ * Put {@link withAccountModels} on a runtime's `openai`, over the provider the runtime composed (pi's remote catalog,
+ * the agent's models.json, and an extension's `registerProvider("openai", …)` included), so none of them is lost. pi
+ * composes a native provider with models.json once more; that second pass is idempotent today, and
+ * openai-account-models.test.ts holds it to that. Call it inside `withModelRegistration`, and again after extensions
+ * load: pi's `registerProvider` drops a native provider, and a refresh without the wrapper would store a credential
+ * without its catalog. Repeating it is harmless.
+ *
+ * Known ceiling: an extension that registers `openai` later than its load (from an event handler) drops the wrapper
+ * for that runtime.
+ */
+export function registerAccountModels(runtime) {
+    const registered = runtime.getRegisteredNativeProvider(OPENAI_PROVIDER);
+    if (registered && wrappedProviders.has(registered))
+        return;
+    const provider = runtime.getProvider(OPENAI_PROVIDER);
+    if (!provider)
+        return;
+    const wrapped = withAccountModels(provider);
+    wrappedProviders.add(wrapped);
+    runtime.registerNativeProvider(wrapped);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastagent-sh/fastagent",
-  "version": "0.24.0",
+  "version": "0.24.1",
   "description": "Vibe first. Then FastAgent: turn a local agent directory into a live service in your app, on Telegram, Slack, Feishu, or behind any channel.",
   "keywords": [
     "agent",