@fastagent-sh/fastagent 0.24.0 → 0.24.2

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

@@ -10,6 +10,8 @@ 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 { asksToEndRun, markEndsRun } from "./turn-kit.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) {
@@ -160,7 +162,7 @@ const nativeExtensions = BUILTIN_EXTENSIONS.map((name) => ({
 /** The resource posture a fastagent definition asks pi for — ONE definition of it, for both assemblies. */
 export function definitionResourceLoaderOptions(source) {
     return {
-        extensionFactories: [...nativeExtensions, compactAdmission],
+        extensionFactories: [...nativeExtensions, compactAdmission, recordEndsRun],
         // The machine's extensions are its owner's setup, not this agent's.
         noExtensions: true,
         // Explicit paths survive noExtensions, including Pi's built-ins; so they would also survive the machine's own
@@ -192,6 +194,29 @@ export function definitionResourceLoaderOptions(source) {
         promptsOverride: () => ({ prompts: [...source.machine.prompts], diagnostics: [] }),
     };
 }
+/**
+ * Records on a tool result that it asked to end its run ({@link asksToEndRun}), so `entries()` can tell a run that
+ * ended on its tool batch from one cut after its tools. Through pi's `message_end` replacement, which runs before pi
+ * appends the message to the record. LAST among the extensions (pi appends inline factories after path ones), so a
+ * definition's own `message_end` replacement cannot drop the flag. One instance per loader, so per session.
+ */
+const recordEndsRun = {
+    name: "fastagent-record-ends-run",
+    hidden: true,
+    factory: (pi) => {
+        const asked = new Set();
+        pi.on("tool_execution_end", (event) => {
+            if (asksToEndRun(event))
+                asked.add(event.toolCallId);
+        });
+        pi.on("message_end", (event) => {
+            const message = event.message;
+            if (message.role !== "toolResult" || !asked.delete(message.toolCallId))
+                return;
+            return { message: markEndsRun(message) };
+        });
+    },
+};
 /** Manual compactions waiting for pi's admission, keyed by the session's record (what an extension's `ctx` names). */
 const compactAdmissions = new WeakMap();
 const COMPACT_ADMISSION = "fastagent-compact-admission";
@@ -275,6 +300,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/invoke-session.js

@@ -10,7 +10,7 @@ import { log } from "../../log.js";
 import { toRetryScheduledEvent } from "./retry-event.js";
 import { PortFailure, port, portAbort, portCleanup, portError } from "../../effect-port.js";
 import { SessionBusy, acquireSession, acquireSessionLease } from "./session-effects.js";
-import { errorToTerminal, inProcessLease, agentEventProjection, answerOutcome, toPiPromptOptions, toTerminal, } from "./turn-kit.js";
+import { errorToTerminal, inProcessLease, agentEventProjection, answerOutcome, asksToEndRun, toPiPromptOptions, toTerminal, } from "./turn-kit.js";
 // Structured output is for scripts. Observation publishes Pi's display result, including bounded nested traces.
 function displayToolResult(result) {
     const { structuredContent: _internal, ...display } = result;
@@ -78,6 +78,7 @@ function toSessionEvent(event, runId) {
                     isError: event.isError,
                     content: displayToolResult(event.result),
                     ...(event.parentToolCallId ? { parentToolCallId: event.parentToolCallId } : {}),
+                    ...(asksToEndRun(event) ? { terminate: true } : {}),
                 },
             };
         case "queue_update":

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/dist/engines/pi/session-control.js

@@ -12,7 +12,7 @@ import { SESSION_BUSY_CODE } from "../../agent.js";
 import { BOUNDARY_COMMAND_FAILED_CODE, INVALID_COMMAND_CODE, isAddressableSession, NO_ACTIVE_RUN_CODE, NOTHING_TO_COMPACT_CODE, NO_SUCH_SESSION_CODE, PARTIAL_UPDATE_CODE, UPDATE_FIELDS, RUN_COMMAND_FAILED_CODE, UNSUPPORTED_CAPABILITY_CODE, } from "../../session.js";
 import { forkProvenance, isConversationMessage, isNavigable, publishedLeaf } from "./session-markers.js";
 import { entryImages, imageAt } from "./entry-images.js";
-import { answerOutcome } from "./turn-kit.js";
+import { answerOutcome, endsRun } from "./turn-kit.js";
 import { startCompaction } from "./agent-session-factory.js";
 import { toRetryScheduledEvent } from "./retry-event.js";
 import { THINKING_LEVELS, activePath, describeModels, resolveSessionSettings } from "./session-settings.js";
@@ -107,6 +107,8 @@ function toSessionEntry(entry, parentId) {
                     isError: m.isError ?? false,
                     text: contentText(m.content, ""),
                     ...entryImages(entry.id, m),
+                    // Same flag as the live `tool_finished` (turn-kit.ts asksToEndRun).
+                    ...(endsRun(m) ? { terminate: true } : {}),
                 },
             };
         }

package/dist/engines/pi/turn-kit.d.ts

@@ -1,4 +1,4 @@
-import { type AssistantMessage, type ImageContent } from "@earendil-works/pi-ai";
+import { type AssistantMessage, type ImageContent, type ToolResultMessage } from "@earendil-works/pi-ai";
 import { type AgentEvent, type Prompt } from "../../agent.ts";
 import type { AnswerOutcome, PromptDisposition, SessionEvent } from "../../session.ts";
 export type Release = () => void;
@@ -18,6 +18,25 @@ export declare function classifyRetryable(details: string, signal: {
  * the recorded one cannot disagree.
  */
 export declare function answerOutcome(message: AssistantMessage): AnswerOutcome | undefined;
+/**
+ * Whether a finished tool call asked to end its run (pi's `terminate`: returned by the tool, or set by a `tool_call`
+ * hook that blocks it; pi 0.99.2's `tool_result` hook cannot set it). After a batch whose EVERY result asks it, pi
+ * makes no further model call for that batch, so unless a queued steer or follow-up continues the run, it completes on
+ * `tool` entries with no answer after them: the same shape a process killed after its tools leaves. A call made from
+ * inside another tool (`parentToolCallId`, a codemode script) is not in the batch and does not count.
+ * The ONE reading: the live `tool_finished` and the flag {@link markEndsRun} records both come from it.
+ */
+export declare function asksToEndRun(event: {
+    result?: unknown;
+    parentToolCallId?: string;
+}): boolean;
+/**
+ * The tool result message as pi then records it, carrying the request: pi's `createToolResultMessage` drops
+ * `terminate` (as of pi 0.99.2), so without this nothing in the record says the run ended on purpose.
+ */
+export declare function markEndsRun(message: ToolResultMessage): ToolResultMessage;
+/** Whether a recorded tool result carries {@link markEndsRun}'s flag. */
+export declare function endsRun(message: ToolResultMessage): boolean;
 /**
  * Terminal mapping, decided by the resolved message's outcome: pi's `prompt()` RESOLVES a message with stopReason
  * "error"/"aborted" rather than throwing, so relying on catch alone would miss that whole failure class and violate

package/dist/engines/pi/turn-kit.js

@@ -91,6 +91,28 @@ export function answerOutcome(message) {
             return undefined;
     }
 }
+/**
+ * Whether a finished tool call asked to end its run (pi's `terminate`: returned by the tool, or set by a `tool_call`
+ * hook that blocks it; pi 0.99.2's `tool_result` hook cannot set it). After a batch whose EVERY result asks it, pi
+ * makes no further model call for that batch, so unless a queued steer or follow-up continues the run, it completes on
+ * `tool` entries with no answer after them: the same shape a process killed after its tools leaves. A call made from
+ * inside another tool (`parentToolCallId`, a codemode script) is not in the batch and does not count.
+ * The ONE reading: the live `tool_finished` and the flag {@link markEndsRun} records both come from it.
+ */
+export function asksToEndRun(event) {
+    return !event.parentToolCallId && event.result?.terminate === true;
+}
+/**
+ * The tool result message as pi then records it, carrying the request: pi's `createToolResultMessage` drops
+ * `terminate` (as of pi 0.99.2), so without this nothing in the record says the run ended on purpose.
+ */
+export function markEndsRun(message) {
+    return { ...message, terminate: true };
+}
+/** Whether a recorded tool result carries {@link markEndsRun}'s flag. */
+export function endsRun(message) {
+    return message.terminate === true;
+}
 /**
  * Terminal mapping, decided by the resolved message's outcome: pi's `prompt()` RESOLVES a message with stopReason
  * "error"/"aborted" rather than throwing, so relying on catch alone would miss that whole failure class and violate

package/dist/session.d.ts

@@ -388,11 +388,17 @@ export type ToolProgressEvent = SessionEvent<"tool_progress", {
 }> & {
     runId: string;
 };
+/**
+ * `terminate: true` when the call asked to end its run. Once every call answering one assistant message asks it, the
+ * model is not called again for them, and the run ends there with no answer after its `tool` entries (which carry the
+ * same flag) unless a queued steer or follow-up continues it. Whether the run ended is `run_settled`'s to say.
+ */
 export type ToolFinishedEvent = SessionEvent<"tool_finished", {
     id: string;
     isError: boolean;
     content: Json;
     parentToolCallId?: string;
+    terminate?: true;
 }> & {
     runId: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastagent-sh/fastagent",
-  "version": "0.24.0",
+  "version": "0.24.2",
   "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",