@fastagent-sh/fastagent 0.23.0 → 0.24.1

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

@@ -1,7 +1,7 @@
 import type { Agent } from "../../agent.ts";
 import { type FastagentConfig } from "./config.ts";
-import type { AgentCommand, SessionControl } from "../../session.ts";
-import { type PiAssembly } from "./create.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";
@@ -72,10 +72,10 @@ export interface AgentAssembly {
     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/, search_tools applied). */
+    /** The full mounted tool surface (all coding tools + config.tools + discovered tools/). */
     tools: MountedTool[];
     toolNames: string[];
-    deferredToolNames: string[];
+    indirectTools: IndirectTool[];
     toolCollisions: ToolCollision[];
     /** Env vars the mounted tools declared, by tool name — already asserted present by this function. */
     toolSecrets: Map<string, DeclaredSecret[]>;
@@ -96,15 +96,19 @@ export declare function assembleFront(front: AgentAssembly, extra?: {
     definition: LoadedDefinition;
 }>;
 /**
- * The model specs `createPiAgentFromDir(dir, { authPath })` could run now: the agent's registry (pi's built-ins plus
- * its `models.json`) filtered to the providers whose credentials are configured, sorted. 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.
+ * 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.
+ * 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<string[]>;
+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
@@ -122,6 +126,19 @@ export declare function refreshModelCatalog(dir: string, options?: FastagentAuth
 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.
@@ -153,7 +170,7 @@ export declare function createPiAgentFromDir(dir: string, options?: CreatePiAgen
     http?: HttpSurface;
     /** Non-default, active-by-default tool names in effect: config.tools + discovered tools/. */
     toolNames: string[];
-    /** Tools registered but not initially active (deferred) — activated via search_tools. */
-    deferredToolNames: 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

@@ -6,6 +6,7 @@ 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";
@@ -14,8 +15,10 @@ import { loadAgentSkills } from "./definition.js";
 import { servedExtensionCommands } from "./agent-session-factory.js";
 import { reportFindingsIfChanged } from "./report.js";
 import { readMachine, withMachine } from "./machine.js";
-import { createPiModelRuntime, refreshCatalog } from "./models.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";
 /**
@@ -36,9 +39,11 @@ export async function agentCommands(agentDir, workspace, served) {
     reportFindingsIfChanged(own.dir, own);
     const machine = await readMachine(workspace);
     const { extensionPaths } = served;
-    const extensionCommands = extensionPaths.length === 0
-        ? []
-        : await servedExtensionCommands({ cwd: workspace, modelRuntime: await served.modelRuntime(), extensionPaths });
+    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 [
@@ -69,7 +74,7 @@ export async function resolveAgentAssembly(dir, options = {}) {
     if (!modelSpec) {
         throw new Error(`missing model: set --model, "model" in fastagent.config.ts, or FASTAGENT_MODEL (e.g. "openai-codex/gpt-5.5")`);
     }
-    const { tools, toolNames, deferredToolNames, toolCollisions, toolFailures, toolSecrets } = await resolveAgentTools(config, agentDir, workspace);
+    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
@@ -79,7 +84,7 @@ export async function resolveAgentAssembly(dir, options = {}) {
     // 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: `search_tools` can activate one mid-turn, so "registered"
+    // 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: [] });
@@ -94,10 +99,10 @@ export async function resolveAgentAssembly(dir, options = {}) {
         workspace,
         stateRoot,
         // Project-level by default (under `<agentDir>/.secrets`), with the global file behind it per provider.
-        models: agentModels(agentDir, options),
+        models: agentModels(agentDir, options, { cwd: workspace }),
         tools,
         toolNames,
-        deferredToolNames,
+        indirectTools,
         toolCollisions,
         toolSecrets,
     };
@@ -118,18 +123,26 @@ export function assembleFront(front, extra = {}) {
     });
 }
 /**
- * The model specs `createPiAgentFromDir(dir, { authPath })` could run now: the agent's registry (pi's built-ins plus
- * its `models.json`) filtered to the providers whose credentials are configured, sorted. 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.
+ * 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.
+ * 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 } = resolvePlacement(dir);
-    const models = await agentModels(agentDir, options).runtime();
-    return (await models.getAvailable()).map((model) => `${model.provider}/${model.id}`).sort();
+    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
@@ -148,10 +161,28 @@ export function refreshModelCatalog(dir, options = {}) {
 export async function refreshModelCatalogOver(dir, options, catalogBaseUrl) {
     const { agentDir } = resolvePlacement(dir);
     const { credentials } = agentModels(agentDir, options);
-    await refreshCatalog((catalogFile) => createPiModelRuntime({
+    await refreshCatalog(join(agentDir, AGENT_MODEL_CATALOG_FILE), (catalogFile) => createPiModelRuntime({
         agentDir,
         credentials,
-        ...(catalogFile ? { catalogFile: join(agentDir, AGENT_MODEL_CATALOG_FILE) } : {}),
+        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 } : {});
 }
@@ -161,7 +192,7 @@ export async function refreshModelCatalogOver(dir, options, catalogBaseUrl) {
  */
 export async function createPiAgentFromDir(dir, options = {}) {
     const front = await resolveAgentAssembly(dir, options);
-    const { config, configPath, modelSpec, agentDir, workspace, stateRoot, models, tools, toolNames, deferredToolNames, toolCollisions, } = front;
+    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);
@@ -201,7 +232,7 @@ export async function createPiAgentFromDir(dir, options = {}) {
             // 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: async () => (await assembly.engine()).modelRuntime,
+                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.
@@ -233,7 +264,7 @@ export async function createPiAgentFromDir(dir, options = {}) {
         sessionsDir,
         models,
         toolNames,
-        deferredToolNames,
+        indirectTools,
         toolCollisions,
     };
 }

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/report.d.ts

@@ -5,6 +5,7 @@
 import type { SkillDiagnostic } from "@earendil-works/pi-agent-core";
 import type { SkillCollision } from "./definition.ts";
 import type { ToolCollision } from "./tool.ts";
+import type { IndirectTool } from "./create.ts";
 type Findings = {
     collisions: SkillCollision[];
     diagnostics: SkillDiagnostic[];
@@ -12,5 +13,7 @@ type Findings = {
 /** 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(collisions: SkillCollision[], diagnostics: SkillDiagnostic[]): void;
+/** 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 {};

package/dist/engines/pi/report.js

@@ -23,6 +23,17 @@ export function reportDefinitionWarnings(collisions, diagnostics) {
         log.warn(`[fastagent] ${d.code}: ${d.message} (${d.path})`);
     }
 }
+const REACH = {
+    tool_search: "loaded via tool_search",
+    codemode: "codemode scripts only",
+    hidden: "hidden",
+    inactive: "inactive until an authored loader activates it",
+    unreachable: "unreachable: pi's settings disable the built-in extension it needs",
+};
+/** The report line for the mounted tools the model is not given up front: each name with its way in. */
+export function describeIndirectTools(tools) {
+    return tools.map((tool) => `${tool.name} (${REACH[tool.reach]})`).join(", ");
+}
 export function reportToolCollisions(collisions) {
     for (const c of collisions) {
         log.warn(`[fastagent] tool "${c.name}" (${c.source}) dropped — a default/config tool already uses that name`);

package/dist/engines/pi/session-builder.js

@@ -4,9 +4,8 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { SessionManager, SettingsManager, createAgentSessionRuntime, createAgentSessionServices, getAgentDir, } from "@earendil-works/pi-coding-agent";
-import { bindPiSession, definitionResourceLoaderOptions, reportExtensionErrors } from "./agent-session-factory.js";
-import { readMachine } from "./machine.js";
+import { SessionManager, SettingsManager, createAgentSessionRuntime, getAgentDir, } from "@earendil-works/pi-coding-agent";
+import { bindPiSession, definitionServices } from "./agent-session-factory.js";
 import { resolveModel } from "./config.js";
 import { canonicalPath } from "./definition.js";
 import { reportToolCollisions } from "./report.js";
@@ -42,29 +41,14 @@ export async function buildAgentSessionRuntime(dir, options = {}, sessionManager
     const createRuntime = async ({ cwd, sessionManager, sessionStartEvent }) => {
         const { modelSpec, assembly, definition } = await assemblyFor(cwd);
         // Per session, NOT memoized with the assembly.
-        const [modelRuntime, machine] = await Promise.all([assembly.modelRuntime(), readMachine(cwd)]);
-        const loaded = await createAgentSessionServices({
-            cwd,
-            // fastagent's models + auth hub replaces pi's default (~/.pi-backed) one — the auth unification point.
-            modelRuntime,
-            // PACKAGELESS, for the loader: fastagent never installs a pi package (machine.ts). Handed pi's own settings, the
-            // loader resolves `packages` itself — installing a missing one, and failing chat's start when that fails.
-            settingsManager: machine.settingsManager(),
-            resourceLoaderOptions: definitionResourceLoaderOptions({
-                systemPrompt: () => definition.systemPrompt,
-                skills: () => definition.skills,
-                machine,
-                extensionPaths: assembly.extensionPaths,
-            }),
-        });
+        const modelRuntime = await assembly.createModelRuntime();
+        const loaded = await definitionServices({ cwd, modelRuntime, definition, extensionPaths: assembly.extensionPaths });
         // ...while the SESSION keeps pi's own file-backed settings, so `/settings` in the TUI still saves. pi persists by
         // re-reading the file under its lock and writing only the fields that changed, so `packages` there is untouched.
         const services = { ...loaded, settingsManager: SettingsManager.create(cwd, loaded.agentDir) };
-        reportExtensionErrors(services);
         // AFTER the services, because an extension may be what defines the model.
         const model = resolveModel(modelRuntime, modelSpec);
-        // The same bind serving performs, minus the activation record: pi's chat session has nowhere to put one, which is
-        // the documented divergence.
+        // Serving and chat restore the same native transcript declarations.
         const result = await bindPiSession({
             services,
             sessionManager,
@@ -74,9 +58,9 @@ export async function buildAgentSessionRuntime(dir, options = {}, sessionManager
             // is the definition's (`thinkingLevel` in fastagent.config.ts), like serving's.
             thinkingLevel: assembly.thinkingLevel,
             tools: assembly.tools,
+            excludedToolNames: assembly.excludedToolNames,
             // A tool must see one spelling of the workspace, including when opened through a symlink.
             cwd: rootCwd,
-            recordActivations: false,
         });
         return { ...result, services, diagnostics: services.diagnostics };
     };

package/dist/engines/pi/session-control.d.ts

@@ -15,7 +15,7 @@
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import { type Models } from "@earendil-works/pi-ai";
 import { type AgentCommand, type SessionControl, type SessionEvent } from "../../session.ts";
-import type { SessionObserver, Lease } from "./turn-kit.ts";
+import { type SessionObserver, type Lease } from "./turn-kit.ts";
 import type { AnyModel } from "./models.ts";
 import type { PiAgentSessionFactory } from "./invoke-session.ts";
 import type { PiSessionRecordStore } from "./session-store.ts";
@@ -25,9 +25,9 @@ export declare const SUBSCRIBER_BUFFER_CAP = 10000;
 export declare const SUBSCRIBER_BUFFER_BYTES: number;
 /** What the plane's writes (`update` / `compact` / `fork` / `delete`) need — the SAME instances the
  *  agent assembly uses: the lease (a write must not race a run), the model registry (validation +
- *  allowedModels), and the session factory (compaction is a model call). Writes go through the
- *  record the hub's reader opened — after an existence check, so the control plane never creates
- *  a session (that is the data plane's monopoly). */
+ *  allowedModels), and the session factory (compaction is a model call). Two writes create a record:
+ *  fork's `into`, and `update()` on an id that has none (through the store's `openOrCreate`, like an
+ *  invoke). Every other write needs a record that exists. */
 export interface PiBoundaryWiring {
     lease: Lease;
     models: Models;