@fastagent-sh/fastagent 0.24.4 → 0.26.0

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

@@ -1,180 +0,0 @@
-import type { Agent } from "../../agent.ts";
-import { type FastagentConfig } from "./config.ts";
-import type { AgentCommand, ModelDescriptor, SessionControl } from "../../session.ts";
-import { type IndirectTool, type PiAssembly } from "./create.ts";
-import type { SessionObserver } from "./turn-kit.ts";
-import { type LoadedDefinition } from "./definition.ts";
-import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
-import type { CredentialStore } from "@earendil-works/pi-ai";
-import type { CredentialSourceOptions, FastagentAuthOptions } from "./auth.ts";
-import { type AgentModels } from "./agent-models.ts";
-import { type PiSessionRecordStore } from "./session-store.ts";
-import type { ToolCollision, MountedTool } from "./tool.ts";
-import type { DeclaredSecret } from "../../declared-secrets.ts";
-import type { HttpSurface } from "../../service.ts";
-/**
- * The names a `/` composer completes: this agent's skills and prompt templates — the definition's, plus the ones its
- * machine lends (machine.ts) — and the commands its `extensions/` register.
- *
- * `source` says how a name is INVOKED, which is the one thing a client needs from it: a `skill` is sent as
- * `/skill:<name>`, an `extension` command and a `prompt` as `/<name>` (docs/design/session-control.md §5.1.1).
- *
- * The definition is read live, like every turn reads it; the machine is the process's one read, the same snapshot a
- * bound session runs on, so the menu cannot offer a name the next prompt would not expand. The same holds for
- * extensions: `served` is what sessions load — the assembly's entry points, discovered once, and the runtime turns run
- * on (asked only when there are extensions) — never a fresh scan of `extensions/`.
- */
-export declare function agentCommands(agentDir: string, workspace: string, served: {
-    extensionPaths: readonly string[];
-    modelRuntime: () => Promise<ModelRuntime>;
-}): Promise<AgentCommand[]>;
-export interface CreatePiAgentFromDirOptions {
-    /** Model spec override (e.g. the CLI --model flag). */
-    model?: string;
-    /**
-     * Where conversations are stored, for an EMBEDDER that puts them somewhere the state root does not cover. There is
-     * no env or flag spelling of it: sessions are machine state, and the one knob that moves machine state is
-     * `FASTAGENT_STATE_DIR` (see {@link resolveSessionsDir}).
-     */
-    sessionsDir?: string;
-    /** Credentials file override. */
-    authPath?: string;
-    /** The caller's own credential store, in place of any file ({@link CredentialSourceOptions}). */
-    credentialStore?: CredentialStore;
-    /**
-     * This is a long-running SERVE (`dev`/`start`), where the scheduler poller runs — so a self-scheduled wake-up is
-     * actually honored.
-     */
-    serving?: boolean;
-    /**
-     * Wire the control plane's BOUNDARY (model changes, fork, delete) and publish it. A serve always gets the hub
-     * itself — stopping the running turn is a chat command, not a management endpoint — so this is the answer to
-     * "may a remote caller steer and rewrite this deployment", nothing else. Defaults to `config.sessionControl`.
-     */
-    sessionControl?: boolean;
-    /** Additional raw tap with the FULL vocabulary. */
-    observer?: SessionObserver;
-}
-/**
- * The agent assembly FRONT HALF — everything that is independent of how pi consumes the definition (a per-invoke
- * session for serving vs a resident one for chat).
- */
-export interface AgentAssembly {
-    config: FastagentConfig;
-    configPath?: string;
-    /**
-     * The default "provider/modelId" spec (`--model` > `FASTAGENT_MODEL` > config), or undefined when the agent sets none:
-     * it still opens, a session that records its model runs on it, and one that records none is refused with
-     * `missing_model` at invoke.
-     */
-    modelSpec?: string;
-    /** Absolute agent dir — definition + config + machinery live here (resolvePlacement().agentDir). */
-    agentDir: string;
-    /** Absolute workspace — the agent's cwd and the start of the ②-context walk. */
-    workspace: string;
-    /** Absolute state root (FASTAGENT_STATE_DIR > <agentDir>/.state). */
-    stateRoot: string;
-    /** The credential store and model registry every turn and every report reads ({@link agentModels}). */
-    models: AgentModels;
-    /** The full mounted tool surface (all coding tools + config.tools + discovered tools/). */
-    tools: MountedTool[];
-    toolNames: string[];
-    indirectTools: IndirectTool[];
-    toolCollisions: ToolCollision[];
-    /** Env vars the mounted tools declared, by tool name — already asserted present by this function. */
-    toolSecrets: Map<string, DeclaredSecret[]>;
-}
-export declare function resolveAgentAssembly(dir: string, options?: {
-    model?: string;
-} & CredentialSourceOptions): Promise<AgentAssembly>;
-/**
- * L2 over a resolved front half: the ONE mapping from what the directory resolved to what the assembly runs on, for
- * both session shapes (the served agent and `chat`'s resident one). Two copies of it drifted once (#566, chat ran at
- * the wrong reasoning effort). `models` is the front's own, so the assembly runs on what the report describes.
- */
-export declare function assembleFront(front: AgentAssembly, extra?: {
-    tools?: MountedTool[];
-    sessions?: PiSessionRecordStore;
-}): Promise<{
-    assembly: PiAssembly;
-    definition: LoadedDefinition;
-}>;
-/**
- * The models `createPiAgentFromDir(dir, { authPath })` could run now, as a picker shows them (spec, name, the thinking
- * levels a session on it accepts, context window), sorted by spec: the agent's registry (pi's built-ins, its
- * `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. 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[]>;
-/**
- * Refresh the agent's model catalog (`<agent dir>/models-store.json`) with the credentials
- * `createPiAgentFromDir(dir, { authPath })` would use, so a model released after the installed pi appears in
- * {@link availableModelsFromDir} and runs. Only providers those credentials authenticate are fetched (pi asks pi.dev
- * for no other). Nothing refreshes it on its own. The file is part of the definition: commit it, and it ships with a
- * deploy, so the deployed agent knows the same models without a network call.
- *
- * Rejects, naming each provider that failed, when the refresh fails, outlasts 15 seconds or `PI_OFFLINE` is set, and
- * when the credentials authenticate no provider at all.
- */
-export declare function refreshModelCatalog(dir: string, options?: FastagentAuthOptions & CredentialSourceOptions & {
-    signal?: AbortSignal;
-}): Promise<void>;
-/** {@link refreshModelCatalog} against another catalog server. Not public: a test seam. */
-export declare function refreshModelCatalogOver(dir: string, options: FastagentAuthOptions & CredentialSourceOptions & {
-    signal?: AbortSignal;
-}, catalogBaseUrl?: string): Promise<void>;
-/**
- * Refresh the MACHINE's model catalog (`~/.fastagent/models-store.json`), which every agent here reads under its own,
- * so one refresh serves them all and no file is written into any agent. Credentials resolve as for
- * {@link refreshModelCatalog} without a directory: `credentialStore`, else `authPath`, else the global credentials file;
- * the environment applies either way. Rejects for the same reasons. The file never ships with a deploy.
- */
-export declare function refreshMachineModelCatalog(options?: FastagentAuthOptions & CredentialSourceOptions & {
-    signal?: AbortSignal;
-}): Promise<void>;
-/** {@link refreshMachineModelCatalog} against another catalog server. Not public: a test seam. */
-export declare function refreshMachineModelCatalogOver(options: FastagentAuthOptions & CredentialSourceOptions & {
-    signal?: AbortSignal;
-}, catalogBaseUrl?: string): Promise<void>;
-/**
- * "Point at a directory → agent": resolve the placement (`dir` may be either end — the workspace or the agent dir
- * itself), load the config, resolve model and tools, then L2.
- */
-export declare function createPiAgentFromDir(dir: string, options?: CreatePiAgentFromDirOptions): Promise<{
-    agent: Agent;
-    definition: LoadedDefinition;
-    config: FastagentConfig;
-    configPath?: string;
-    /** The default "provider/modelId" spec, or undefined when the agent sets none ({@link AgentAssembly.modelSpec}). */
-    modelSpec?: string;
-    /** Absolute agent dir in use — channels/tools/prompt come from here. */
-    agentDir: string;
-    /** Absolute workspace in use — the agent's cwd: ALWAYS the directory that was pointed at. */
-    workspace: string;
-    /** Absolute state root in use (FASTAGENT_STATE_DIR > <agentDir>/.state) — the ChannelContext's stateRoot. */
-    stateRoot: string;
-    /** Absolute session store directory in use (for the startup report). */
-    sessionsDir: string;
-    /** The credential store and registry the agent runs on — what the startup report describes. */
-    models: AgentModels;
-    sessions: PiSessionRecordStore;
-    /** The observation plane over this agent's sessions; present on every serve (a channel's stop command reaches the
-     *  live run through it). Its boundary is wired only when {@link publishControl}. */
-    sessionControl?: SessionControl;
-    /** Whether that plane is also served as `/control/*` — `config.sessionControl`. */
-    publishControl: boolean;
-    /** What the serve publishes — `config.http`, handed to the assembly as-is (MountableAgent). */
-    http?: HttpSurface;
-    /** Non-default, active-by-default tool names in effect: config.tools + discovered tools/. */
-    toolNames: string[];
-    /** Mounted authored tools the model is not given up front, with how each is reached. */
-    indirectTools: IndirectTool[];
-    toolCollisions: ToolCollision[];
-}>;

package/dist/engines/pi/open.js

@@ -1,270 +0,0 @@
-/**
- * Open a definition directory into an agent — the single agent opener BOTH `fastagent dev` and `fastagent start`
- * drive.
- */
-import { mkdir } from "node:fs/promises";
-import { join } from "node:path";
-import { loadConfig, resolveModelSpec } from "./config.js";
-import { AGENT_MODEL_CATALOG_FILE, resolveSessionsDir, resolveStateRoot, resolvePlacement } from "../../paths.js";
-import { describeModels } from "./session-settings.js";
-import { agentOf, assemblePiFromDefinition, resolveAgentTools } from "./create.js";
-import { createPiSessionControl } from "./session-control.js";
-import { withWakeTool } from "./wake-tool.js";
-import { refuseBrokenDeclarations } from "../../loader.js";
-import { loadAgentDefinition } from "./definition.js";
-import { servedExtensionCommands } from "./agent-session-factory.js";
-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";
-/**
- * The names a `/` composer completes: this agent's skills and prompt templates — the definition's, plus the ones its
- * machine lends (machine.ts) — and the commands its `extensions/` register.
- *
- * `source` says how a name is INVOKED, which is the one thing a client needs from it: a `skill` is sent as
- * `/skill:<name>`, an `extension` command and a `prompt` as `/<name>` (docs/design/session-control.md §5.1.1).
- *
- * The definition is read live, like every turn reads it; the machine is the process's one read, the same snapshot a
- * bound session runs on, so the menu cannot offer a name the next prompt would not expand. The same holds for
- * extensions: `served` is what sessions load — the assembly's entry points, discovered once, and the runtime turns run
- * on (asked only when there are extensions) — never a fresh scan of `extensions/`.
- */
-export async function agentCommands(agentDir, workspace, served) {
-    // The whole definition, read the way a turn reads it: a skill whose frontmatter broke simply is not in `skills`, and
-    // would vanish from the composer with no signal. The SAME findings a turn reports, so the per-directory memo sees
-    // one set from both readers instead of warning again after every menu request.
-    const own = await loadAgentDefinition(agentDir, { cwd: workspace });
-    reportFindingsIfChanged(own.dir, own);
-    const machine = await readMachine(workspace);
-    const prompts = withMachine(own.prompts, machine.prompts);
-    const { extensionPaths } = served;
-    const extensionCommands = await servedExtensionCommands({
-        cwd: workspace,
-        modelRuntime: await served.modelRuntime(),
-        extensionPaths,
-    });
-    // pi dispatches an extension command before it expands a template, so a template it shadows never runs.
-    const shadowed = new Set(extensionCommands.map((command) => command.invocationName));
-    return [
-        ...withMachine(own.skills, machine.skills).map((skill) => ({
-            name: skill.name,
-            description: skill.description,
-            source: "skill",
-        })),
-        ...extensionCommands.map((command) => ({
-            name: command.invocationName,
-            ...(command.description ? { description: command.description } : {}),
-            source: "extension",
-        })),
-        ...prompts
-            .filter((prompt) => !shadowed.has(prompt.name))
-            .map((prompt) => ({
-            name: prompt.name,
-            ...(prompt.description ? { description: prompt.description } : {}),
-            source: "prompt",
-        })),
-    ];
-}
-export async function resolveAgentAssembly(dir, options = {}) {
-    // Placement is structural (resolvePlacement): the AGENT DIR carries definition + config + machinery; its parent.
-    const { agentDir, workspace } = resolvePlacement(dir);
-    const { config, path: configPath } = await loadConfig(agentDir);
-    const modelSpec = resolveModelSpec(options.model, config);
-    const { tools, toolNames, indirectTools, toolCollisions, toolFailures, toolSecrets } = await resolveAgentTools(config, agentDir, workspace);
-    // THE serving-path gate for tool declarations, in the order that costs the fewest round trips. A file that could
-    // not be imported declares nothing, so its `secrets:` are missing from `toolSecrets` — gating secrets first would
-    // report an incomplete set, and fixing the file could then reveal more missing values. Refuse the broken file
-    // first and one pass reports every secret the definition actually wants.
-    refuseBrokenDeclarations(toolFailures);
-    // Both gates live here rather than inside resolveAgentTools, which `info` and `fastagent tool` call to REPORT on a
-    // definition and must survive both faults; every path through this function is about to run ALL of the tools, so
-    // no `owner`.
-    //
-    // DEFERRED tools gate too, deliberately: native discovery can activate one mid-turn, so "registered"
-    // means "may run in this process" — letting it start would put the empty-credential failure back
-    // inside a turn. An author who does not want that opts out per tool by not declaring.
-    gateSecrets({ declared: toolSecrets, failures: [] });
-    // The state root: sessions/channel state/schedule state derive from it (FASTAGENT_STATE_DIR moves it in one knob —
-    // a container points it at its volume).
-    const stateRoot = resolveStateRoot(agentDir);
-    return {
-        config,
-        configPath,
-        ...(modelSpec ? { modelSpec } : {}),
-        agentDir,
-        workspace,
-        stateRoot,
-        // Project-level by default (under `<agentDir>/.secrets`), with the global file behind it per provider.
-        models: agentModels(agentDir, options, { cwd: workspace }),
-        tools,
-        toolNames,
-        indirectTools,
-        toolCollisions,
-        toolSecrets,
-    };
-}
-/**
- * L2 over a resolved front half: the ONE mapping from what the directory resolved to what the assembly runs on, for
- * both session shapes (the served agent and `chat`'s resident one). Two copies of it drifted once (#566, chat ran at
- * the wrong reasoning effort). `models` is the front's own, so the assembly runs on what the report describes.
- */
-export function assembleFront(front, extra = {}) {
-    return assemblePiFromDefinition(front.agentDir, {
-        ...(front.modelSpec ? { model: front.modelSpec } : {}),
-        thinkingLevel: front.config.thinkingLevel,
-        cwd: front.workspace,
-        tools: extra.tools ?? front.tools,
-        models: front.models,
-        ...(extra.sessions ? { sessions: extra.sessions } : {}),
-    });
-}
-/**
- * The models `createPiAgentFromDir(dir, { authPath })` could run now, as a picker shows them (spec, name, the thinking
- * levels a session on it accepts, context window), sorted by spec: the agent's registry (pi's built-ins, its
- * `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. 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 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
- * `createPiAgentFromDir(dir, { authPath })` would use, so a model released after the installed pi appears in
- * {@link availableModelsFromDir} and runs. Only providers those credentials authenticate are fetched (pi asks pi.dev
- * for no other). Nothing refreshes it on its own. The file is part of the definition: commit it, and it ships with a
- * deploy, so the deployed agent knows the same models without a network call.
- *
- * Rejects, naming each provider that failed, when the refresh fails, outlasts 15 seconds or `PI_OFFLINE` is set, and
- * when the credentials authenticate no provider at all.
- */
-export function refreshModelCatalog(dir, options = {}) {
-    return refreshModelCatalogOver(dir, options);
-}
-/** {@link refreshModelCatalog} against another catalog server. Not public: a test seam. */
-export async function refreshModelCatalogOver(dir, options, catalogBaseUrl) {
-    const { agentDir } = resolvePlacement(dir);
-    const { credentials } = agentModels(agentDir, options);
-    await refreshCatalog(join(agentDir, AGENT_MODEL_CATALOG_FILE), (catalogFile) => createPiModelRuntime({
-        agentDir,
-        credentials,
-        catalogFile,
-        ...(catalogBaseUrl ? { catalogBaseUrl } : {}),
-    }), options.signal ? { signal: options.signal } : {});
-}
-/**
- * Refresh the MACHINE's model catalog (`~/.fastagent/models-store.json`), which every agent here reads under its own,
- * so one refresh serves them all and no file is written into any agent. Credentials resolve as for
- * {@link refreshModelCatalog} without a directory: `credentialStore`, else `authPath`, else the global credentials file;
- * the environment applies either way. Rejects for the same reasons. The file never ships with a deploy.
- */
-export function refreshMachineModelCatalog(options = {}) {
-    return refreshMachineModelCatalogOver(options);
-}
-/** {@link refreshMachineModelCatalog} against another catalog server. Not public: a test seam. */
-export async function refreshMachineModelCatalogOver(options, catalogBaseUrl) {
-    const { credentials } = agentModels(undefined, options);
-    await refreshCatalog(globalCatalogPath(), (catalogFile) => machineModelRuntime({
-        credentials,
-        catalogFile,
-        ...(catalogBaseUrl ? { catalogBaseUrl } : {}),
-    }), options.signal ? { signal: options.signal } : {});
-}
-/**
- * "Point at a directory → agent": resolve the placement (`dir` may be either end — the workspace or the agent dir
- * itself), load the config, resolve model and tools, then L2.
- */
-export async function createPiAgentFromDir(dir, options = {}) {
-    const front = await resolveAgentAssembly(dir, options);
-    const { config, configPath, modelSpec, agentDir, workspace, stateRoot, models, tools, toolNames, indirectTools, toolCollisions, } = front;
-    // Every serve mounts the built-in `wake` tool: the agent's own follow-up work is a default capability, and a serve
-    // is where the poller that honors it runs. A one-shot `invoke` has no poller, so nothing there would fire it.
-    const mountedTools = withWakeTool(tools, stateRoot, !!options.serving);
-    // An explicit value is used as given (the store resolves a relative one against the WORKSPACE); without one, the
-    // resolution every reader shares (config.ts), so a serve and an `info` never report on different directories.
-    const sessionsDir = options.sessionsDir ?? resolveSessionsDir(agentDir);
-    await mkdir(sessionsDir, { recursive: true });
-    const sessions = piSessionRecordStore({ dir: sessionsDir, cwd: workspace });
-    // Skills are definition-only (the agent is its directory), so dev mirrors deployment exactly.
-    const { assembly, definition } = await assembleFront(front, { tools: mountedTools, sessions });
-    // The hub is wired HERE because the store is created here (an external `createPiSessionControl` cannot exist before
-    // the store does).
-    const caller = options.observer;
-    // TWO decisions, not one. The hub is in-process bookkeeping over the run observer: a serve gets it unconditionally,
-    // because `/stop` in a chat is an ordinary thing to ask for and reaching the live run is the only way to answer it.
-    // Publishing `/control/*` — steer, rewrite, delete, unauthenticated at whatever URL this serves on — is the
-    // separate decision `config.sessionControl` makes, and it is the only one that also wires the boundary.
-    const publish = options.sessionControl ?? config.sessionControl === true;
-    const wantControl = publish || options.serving === true;
-    let hub;
-    if (wantControl) {
-        // The hub's surface is synchronous (`capabilities()` lists the allowed models), while building the registry reads
-        // credentials and is not. Resolved only when the boundary is wired, so an ordinary serve does not pay for it.
-        const boundary = publish
-            ? await assembly.engine().then(({ modelRuntime, model }) => ({
-                lease: assembly.lease,
-                models: modelRuntime,
-                sessionFactory: assembly.sessionFactory,
-                defaults: { ...(model ? { model } : {}), thinkingLevel: assembly.thinkingLevel },
-            }))
-            : undefined;
-        hub = createPiSessionControl({
-            sessions,
-            boundary,
-            // What a client offers is what a turn WOULD run, which since this agent inherits its machine is not the
-            // definition alone. Built through the same resource posture the turn uses, so the menu cannot list a name
-            // the prompt would not expand — a second reading of "which skills exist" is how those two come to disagree.
-            commands: () => agentCommands(agentDir, workspace, {
-                extensionPaths: assembly.extensionPaths,
-                modelRuntime: assembly.createModelRuntime,
-            }),
-            // The caller tap's boundary-event half: state_changed/compaction_* originate in the hub and never cross the
-            // data plane's observer seam.
-            tap: caller ? (session, event) => caller(session, event) : undefined,
-        });
-    }
-    const observer = hub
-        ? caller
-            ? (session, event, run) => {
-                hub.observer(session, event, run);
-                caller(session, event, run);
-            }
-            : hub.observer
-        : caller;
-    const agent = agentOf(assembly, observer);
-    return {
-        agent,
-        definition,
-        sessions,
-        sessionControl: hub?.control,
-        publishControl: publish,
-        http: config.http,
-        agentDir,
-        workspace,
-        config,
-        configPath,
-        ...(modelSpec ? { modelSpec } : {}),
-        stateRoot,
-        sessionsDir,
-        models,
-        toolNames,
-        indirectTools,
-        toolCollisions,
-    };
-}

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

@@ -1,35 +0,0 @@
-/**
- * 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

@@ -1,116 +0,0 @@
-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/report.d.ts

@@ -1,18 +0,0 @@
-import type { DefinitionDiagnostic, DefinitionShadow, LoadedDefinition, SkillCollision } from "./definition.ts";
-import type { ToolCollision } from "./tool.ts";
-import type { IndirectTool } from "./create.ts";
-type Findings = {
-    collisions: SkillCollision[];
-    diagnostics: DefinitionDiagnostic[];
-    shadowed?: DefinitionShadow[];
-    ignored?: LoadedDefinition["ignored"];
-};
-/** THE door for definition findings: warns only when this dir's set CHANGED since the last report. */
-export declare function reportFindingsIfChanged(dir: string, def: Findings): void;
-export declare function reportDefinitionWarnings(def: Findings): void;
-/** What the agent's system prompt is made of, as a report line: pi's default or `SYSTEM.md`, plus an addendum. */
-export declare function describePrompt(def: Pick<LoadedDefinition, "dir" | "systemPrompt" | "appendSystemPrompt">): string;
-/** The report line for the mounted tools the model is not given up front: each name with its way in. */
-export declare function describeIndirectTools(tools: readonly IndirectTool[]): string;
-export declare function reportToolCollisions(collisions: ToolCollision[]): void;
-export {};