@fastagent-sh/fastagent 0.23.0 → 0.24.1

package/dist/agent.d.ts

@@ -47,6 +47,16 @@ export type AgentEvent = {
     isError: boolean;
     content: Json;
 }
+/**
+ * Advisory, non-terminal (engines MAY emit it): the running tool `id`'s current status, one line, replacing the last.
+ * It may be a line of the tool's output so far (trust it like `tool_ended.content`), never the whole output;
+ * untruncated, so a consumer that shows it clips it.
+ */
+ | {
+    type: "tool_progress";
+    id: string;
+    text: string;
+}
 /**
  * Advisory, non-terminal (engines MAY emit it): a transient internal failure scheduled a retry with backoff — the
  * turn is still alive.

package/dist/channels/kit/preview-kit.d.ts

@@ -23,6 +23,8 @@ export declare const THINKING_PLACEHOLDER = "\uD83D\uDCAD Thinking\u2026";
 interface ToolLine {
     label: string;
     status: "running" | "ok" | "error";
+    /** The call's latest `tool_progress` text, shown while it runs. */
+    progress?: string;
 }
 /** The channel-neutral view STATE of one in-flight turn. */
 export interface TurnView {
@@ -38,7 +40,10 @@ export interface TurnView {
 }
 export declare function createTurnView(): TurnView;
 export declare function applyTurnEvent(view: TurnView, e: AgentEvent, now?: number): boolean;
-/** The tool-activity block: one `🔧 label …/✓/✗` line per call, in call order. */
+/**
+ * The tool-activity block: one `🔧 label …/✓/✗` line per call, in call order. A running call shows its latest
+ * progress after the mark (`🔧 Bash npm test … › 42 passed`); a finished one drops it.
+ */
 export declare function toolLines(view: TurnView): string;
 /** The reasoning peek: the most recent tail of the (growing) reasoning, one line, code-point safe. */
 export declare function thinkingLine(view: TurnView, maxTail: number): string;

package/dist/channels/kit/preview-kit.js

@@ -36,6 +36,13 @@ export function applyTurnEvent(view, e, now = Date.now()) {
             view.toolById.set(e.id, line);
             return true;
         }
+        case "tool_progress": {
+            const line = view.toolById.get(e.id);
+            if (line?.status !== "running")
+                return closedRetry;
+            line.progress = e.text;
+            return true;
+        }
         case "tool_ended": {
             const line = view.toolById.get(e.id);
             if (line)
@@ -50,9 +57,17 @@ export function applyTurnEvent(view, e, now = Date.now()) {
     }
 }
 const TOOL_MARK = { running: "…", ok: "✓", error: "✗" };
-/** The tool-activity block: one `🔧 label …/✓/✗` line per call, in call order. */
+/**
+ * The tool-activity block: one `🔧 label …/✓/✗` line per call, in call order. A running call shows its latest
+ * progress after the mark (`🔧 Bash npm test … › 42 passed`); a finished one drops it.
+ */
 export function toolLines(view) {
-    return view.tools.map((t) => `🔧 ${t.label} ${TOOL_MARK[t.status]}`).join("\n");
+    return view.tools
+        .map((t) => {
+        const progress = t.status === "running" && t.progress ? ` › ${clip(t.progress, TOOL_PROGRESS_MAX)}` : "";
+        return `🔧 ${t.label} ${TOOL_MARK[t.status]}${progress}`;
+    })
+        .join("\n");
 }
 /** The reasoning peek: the most recent tail of the (growing) reasoning, one line, code-point safe. */
 export function thinkingLine(view, maxTail) {
@@ -77,15 +92,17 @@ export function composeTurnBody(parts) {
 }
 /** Max length (code points) of a tool's arg preview. */
 const TOOL_ARG_MAX = 48;
+/** Max length (code points) of a running tool's progress line: one status, not its output. */
+const TOOL_PROGRESS_MAX = 64;
 /** Max length (code points) of a humanized tool label. */
 const TOOL_NAME_MAX = 80;
 /**
  * One-line, truncated at code-point boundaries: collapse whitespace so a multi-line command/arg stays on one line, and
  * never tear a surrogate pair mid-emoji.
  */
-function clip(s) {
+function clip(s, max = TOOL_ARG_MAX) {
     const one = s.replace(/\s+/g, " ").trim();
-    return truncateCodePointPrefix(one, TOOL_ARG_MAX);
+    return truncateCodePointPrefix(one, max);
 }
 /**
  * A compact, human-readable preview of a tool call's args so the live view reads `🔧 read AGENTS.md` rather than just

package/dist/channels/slack/preview.js

@@ -119,7 +119,8 @@ function streamClassicSlackReply(events, api, target, formatError, initialPrevie
         let lastSent = "";
         const view = () => composeTurnBody([
             THINKING_PLACEHOLDER,
-            toolLines(turn),
+            // Tool names, arguments and progress lines are untrusted text, like the answer.
+            sanitizeSlackMarkdown(toolLines(turn)),
             turn.retrying ? RETRY_NOTICE : "",
             sanitizeSlackMarkdown(revealedAnswer(turn, CLASSIC_UPDATE_INTERVAL_MS, now())),
         ]);

package/dist/cli/commands/info.js

@@ -8,7 +8,7 @@ import { agentModels } from "../../engines/pi/agent-models.js";
 import { resolveSessionsDir, resolveStateRoot } from "../../paths.js";
 import { CODING_TOOL_NAMES, resolveAgentTools } from "../../engines/pi/create.js";
 import { loadAgentDefinition } from "../../engines/pi/definition.js";
-import { reportFindingsIfChanged, reportToolCollisions } from "../../engines/pi/report.js";
+import { describeIndirectTools, reportFindingsIfChanged, reportToolCollisions } from "../../engines/pi/report.js";
 import { allSecrets, describeSecrets, missingSecrets } from "../../declared-secrets.js";
 import { log } from "../../log.js";
 import { reportModuleLoadFailures } from "../../loader.js";
@@ -32,7 +32,7 @@ export async function runInfo(dirArg, opts) {
     const tools = await resolveAgentTools(config, agentDir, workspace)
         .then((r) => ({
         names: r.toolNames,
-        deferred: r.deferredToolNames,
+        indirect: r.indirectTools,
         collisions: r.toolCollisions,
         failures: r.toolFailures,
         secrets: allSecrets(r.toolSecrets),
@@ -40,7 +40,7 @@ export async function runInfo(dirArg, opts) {
     }))
         .catch((e) => ({
         names: [],
-        deferred: [],
+        indirect: [],
         collisions: [],
         failures: [],
         secrets: [],
@@ -75,7 +75,7 @@ export async function runInfo(dirArg, opts) {
     const sessionsDir = resolveSessionsDir(agentDir);
     // Both layers: "what is this agent's state" is the question `info` answers, and a credential it runs on can live in
     // a file the agent dir does not contain.
-    const models = agentModels(agentDir);
+    const models = agentModels(agentDir, {}, { cwd: workspace });
     const { auth } = models;
     // RESOLVE the spec, do not just echo it: a spec is only real once its provider/model exist in the agent's own
     // surface (built-ins + its models.json), which is exactly what a custom endpoint changes.
@@ -107,7 +107,7 @@ export async function runInfo(dirArg, opts) {
             persona: definition.persona !== undefined,
             skills: skills.map((skill) => ({ name: skill.name, description: skill.description })),
             tools: tools.names,
-            deferredTools: tools.deferred,
+            indirectTools: tools.indirect,
             toolError: tools.error ?? null,
             channels,
             routines,
@@ -145,8 +145,8 @@ export async function runInfo(dirArg, opts) {
     line("persona", definition.persona ? "persona.md" : "(none)");
     line("skills", skills.map((skill) => skill.name).join(", ") || "(none)");
     line("tools", tools.error ? "(could not load — see warning below)" : tools.names.join(", ") || "(none)");
-    if (tools.deferred.length > 0)
-        line("deferred", `${tools.deferred.join(", ")} (activated via search_tools)`);
+    if (tools.indirect.length > 0)
+        line("indirect", describeIndirectTools(tools.indirect));
     line("channels", channels.join(", ") || "(none)");
     line("routines", routines.map((r) => `${r.name} (${r.cron === null ? "on demand" : `next ${r.next ?? "never"}`})`).join(", ") ||
         "(none)");

package/dist/cli/commands/login.js

@@ -9,7 +9,7 @@ import { enterAgentEnv } from "../../env.js";
 import { GLOBAL_AUTH_PATH, resolveAuthPath } from "../../engines/pi/auth.js";
 import { agentModels } from "../../engines/pi/agent-models.js";
 import { DEPLOY_HOSTS } from "../../deploy/hosts.js";
-import { findAgentDir, globalHome, placementDeadEnd } from "../../paths.js";
+import { findAgentDir, globalHome, placementDeadEnd, resolvePlacement } from "../../paths.js";
 import { LoginCancelled, loginFlow } from "../../engines/pi/login.js";
 import { environmentAuthSource } from "../../engines/pi/models.js";
 import { loginOnBox } from "../box-login.js";
@@ -148,7 +148,7 @@ async function stdioLogin(io, provider, opts) {
     enterAgentEnv(agentDir);
     // The model environment the serving runtime reads (createPiAgentFromDir), so "logged in" means what the server will
     // use.
-    const models = agentModels(agentDir);
+    const models = agentModels(agentDir, {}, { cwd: resolvePlacement(agentDir).workspace });
     const { auth } = models;
     if (opts.ifMissing && provider) {
         // The server's own answer (`authStatus`), the one its startup report prints. Known ceiling: nothing is asked of

package/dist/cli/commands/models.js

@@ -7,8 +7,8 @@ import { join } from "node:path";
 import { InMemoryCredentialStore } from "@earendil-works/pi-ai";
 import { formatModelsCommand } from "../models-view.js";
 import { listModels } from "../../engines/pi/config.js";
-import { createPiModelRuntime, globalCatalogPath, machineModelRuntime, refreshGlobalModelCatalog, } from "../../engines/pi/models.js";
-import { refreshModelCatalog } from "../../engines/pi/open.js";
+import { createPiModelRuntime, globalCatalogPath, machineModelRuntime } from "../../engines/pi/models.js";
+import { refreshMachineModelCatalog, refreshModelCatalog } from "../../engines/pi/open.js";
 import { AGENT_MODEL_CATALOG_FILE, findAgentDir, globalHome, placementDeadEnd } from "../../paths.js";
 import { enterAgentEnv } from "../../env.js";
 import { failStartup, placementOrExit } from "../fail.js";
@@ -29,7 +29,7 @@ export async function runModels(search, opts = {}) {
             console.error(`[fastagent] refreshed ${join(agentDir, AGENT_MODEL_CATALOG_FILE)} — commit it: it ships with a deploy`);
         }
         else {
-            await refreshGlobalModelCatalog().catch(failStartup);
+            await refreshMachineModelCatalog().catch(failStartup);
             console.error(`[fastagent] refreshed ${globalCatalogPath()} — every agent on this machine reads it`);
         }
     }

package/dist/cli/invoke-stream.js

@@ -10,6 +10,9 @@ export async function runInvokeStream(events, out, err) {
                 toolName.set(event.id, event.name);
                 err(`[tool] ${event.name}`);
                 break;
+            case "tool_progress":
+                err(`[tool] ${toolName.get(event.id) ?? event.id} › ${clipStatus(event.text)}`);
+                break;
             case "tool_ended":
                 if (event.isError)
                     err(`[tool] ${toolName.get(event.id) ?? event.id} failed`);
@@ -28,3 +31,14 @@ export async function runInvokeStream(events, out, err) {
     }
     return exitCode;
 }
+/** How much of a status line a terminal gets, in code points. */
+const STATUS_MAX = 120;
+/**
+ * A `tool_progress` line clipped to {@link STATUS_MAX} code points. The event is untruncated by contract, and a shell
+ * printing one long line (`curl -s` of a JSON body) re-sends that growing line every 100 ms.
+ */
+function clipStatus(text) {
+    // Only the first STATUS_MAX + 1 code points decide the result, and they fit in twice as many UTF-16 units.
+    const head = [...text.slice(0, (STATUS_MAX + 1) * 2)];
+    return head.length > STATUS_MAX ? `${head.slice(0, STATUS_MAX).join("")}…` : head.join("");
+}

package/dist/cli/shared.d.ts

@@ -1,5 +1,6 @@
 import { type LoginIO } from "../engines/pi/login.ts";
 import { type AgentModels } from "../engines/pi/agent-models.ts";
+import { type IndirectTool } from "../engines/pi/create.ts";
 import type { LoadedDefinition } from "../engines/pi/definition.ts";
 import type { ToolCollision } from "../engines/pi/tool.ts";
 import { type ResolvedPlacement } from "../paths.ts";
@@ -19,7 +20,7 @@ export interface ReportableAssembly {
     };
     definition: LoadedDefinition;
     toolNames: string[];
-    deferredToolNames: string[];
+    indirectTools: IndirectTool[];
     toolCollisions: ToolCollision[];
 }
 /** What `dev` and `start` say about the directory they just opened, in the order they say it. */

package/dist/cli/shared.js

@@ -13,7 +13,7 @@ import { providerAuthStatuses } from "../engines/pi/models.js";
 import { agentModels } from "../engines/pi/agent-models.js";
 import { formatAuthReport } from "./auth-view.js";
 import { CODING_TOOL_NAMES } from "../engines/pi/create.js";
-import { reportFindingsIfChanged, reportToolCollisions } from "../engines/pi/report.js";
+import { describeIndirectTools, reportFindingsIfChanged, reportToolCollisions } from "../engines/pi/report.js";
 import { isDeployedWorkspace } from "../paths.js";
 import { log } from "../log.js";
 import { enterAgentEnv } from "../env.js";
@@ -24,7 +24,7 @@ import { failStartup, failUsage, placementOrExit } from "./fail.js";
 export async function enterAgentCommand(dirArg, opts) {
     const placement = placementOrExit(resolve(dirArg));
     enterAgentEnv(placement.agentDir);
-    await resolveFirstRunModel(placement.agentDir, opts);
+    await resolveFirstRunModel(placement, opts);
     return placement;
 }
 /** The padded label writer for the STARTUP report (`dev`/`start`, stderr via the log level). */
@@ -48,9 +48,8 @@ export async function reportAssembly(a, extras = {}) {
     reportLine("codingTools", CODING_TOOL_NAMES.join(", "));
     if (a.toolNames.length > 0)
         reportLine("tools", a.toolNames.join(", "));
-    if (a.deferredToolNames.length > 0) {
-        reportLine("deferred", `${a.deferredToolNames.join(", ")} (activated via search_tools)`);
-    }
+    if (a.indirectTools.length > 0)
+        reportLine("indirect", describeIndirectTools(a.indirectTools));
     reportToolCollisions(a.toolCollisions);
     for (const [label, value] of extras.afterTools ?? [])
         reportLine(label, value);
@@ -107,7 +106,7 @@ export async function reportAuth(models, modelSpec) {
 /**
  * First-run model resolution for every assembly command (dev/start/invoke/fire/chat/deploy): ONE funnel, no dead ends.
  */
-async function resolveFirstRunModel(agentDir, options = {}) {
+async function resolveFirstRunModel({ agentDir, workspace }, options = {}) {
     const { config, path: configPath } = await loadConfig(agentDir).catch(failStartup);
     if (resolveModelSpec(options.model, config))
         return; // already set (flag > FASTAGENT_MODEL > config)
@@ -115,7 +114,7 @@ async function resolveFirstRunModel(agentDir, options = {}) {
         return; // --no-input: never prompt (clig) — the opener raises the clear error
     if (!isInteractive())
         return; // CI/deploy: the opener throws the actionable missing-model error
-    const environment = agentModels(agentDir);
+    const environment = agentModels(agentDir, {}, { cwd: workspace });
     // The picker lists the AGENT's surface: built-ins plus whatever its models.json declares, so a self-hosted endpoint
     // is pickable on first run instead of being invisible until hand-set.
     const models = await environment.runtime().catch(failStartup);

package/dist/deploy/preflight.js

@@ -13,6 +13,7 @@ import { AGENT_MODEL_CATALOG_FILE, AGENT_MODELS_FILE, exists } from "../paths.js
 import { inspectChannels } from "../channels/discover.js";
 import { loadRoutines } from "../schedule/discover.js";
 import { resolveAgentTools } from "../engines/pi/create.js";
+import { agentModels } from "../engines/pi/agent-models.js";
 import { allSecrets } from "../declared-secrets.js";
 import { createPiModelRuntime, definitionKeyOf, environmentAuthSource, literalKeyProviders, isBuiltinProvider, machineModels, globalCatalogPath, inGlobalCatalog, interactiveLoginKind, loginProviders, } from "../engines/pi/models.js";
 import { CHANNEL_KINDS } from "../scaffold/add-channel.js";
@@ -160,7 +161,15 @@ async function gatherFacts(input, report) {
     if (modelSpec)
         await checkGlobalCatalogModel(modelSpec, deployed, report);
     const authPath = resolveAuthPath(agentDir);
-    const route = modelSpec ? await credentialRoute(agentDir, modelSpec, values) : {};
+    // A model only the definition's extensions declare (a virtual model, or a provider one registers) is authenticated
+    // by that code on the box, per request: a virtual model's credential is whichever physical model it routes to.
+    // Asked of the catalog the box builds, extensions included, so deploy judges the model the box will run.
+    const fromExtension = modelSpec ? await extensionDeclared(agentDir, workspace, modelSpec, deployed) : false;
+    if (fromExtension && modelSpec) {
+        report.note(`${modelSpec} is declared by the definition's extensions, which resolve its credentials on the box — deploy ` +
+            `cannot check them. Set the keys the models it uses need in ${valueFile}`);
+    }
+    const route = modelSpec && !fromExtension ? await credentialRoute(agentDir, modelSpec, values) : {};
     const modelAuth = route.envVar;
     const boxLogin = route.boxLogin;
     if (boxLogin !== undefined) {
@@ -297,6 +306,15 @@ async function credentialRoute(agentDir, spec, values) {
         return isEnvKey(fromValues) ? { envVar: fromValues } : {};
     return { boxLogin: provider };
 }
+/** Whether `spec` exists only once the definition's extensions have registered their models. */
+async function extensionDeclared(agentDir, workspace, spec, deployed) {
+    const provider = providerOf(spec);
+    const id = spec.slice(provider.length + 1);
+    if (deployed.getModel(provider, id))
+        return false;
+    const catalog = await agentModels(agentDir, { credentialStore: new InMemoryCredentialStore() }, { machineLayer: false, cwd: workspace }).runtime();
+    return catalog.getModel(provider, id) !== undefined;
+}
 /** Does `provider` offer an interactive login, i.e. can `fastagent login --deployment` authenticate it on the box? */
 function hasLogin(providerId) {
     const provider = loginProviders().find((p) => p.id === providerId);

package/dist/dev-supervisor.js

@@ -29,8 +29,8 @@ export function devWatchIgnored(root, envFile) {
             return false;
         if (rel === "package.json")
             return false;
-        // models.json is read ONCE per worker (the model hub is built during assembly), so an edit needs a restart like
-        // any other code input.
+        // models.json is read ONCE per worker (agentModels' snapshot, which every session's runtime is built from), so an
+        // edit needs a restart like any other code input.
         if (rel === AGENT_MODELS_FILE)
             return false;
         // So is the model catalog: a `models --refresh` during `dev` restarts the worker onto the new models.

package/dist/engines/pi/agent-models.d.ts

@@ -5,6 +5,7 @@
  * login, the model list — so none of them can read other credential layers or another registry than the runtime
  * does. Each used to compose these parts itself, and two of those copies drifted from the rule (#636, #660).
  */
+import type { ExecutionEnv } from "@earendil-works/pi-agent-core";
 import type { Credential, CredentialStore, Models, Provider } from "@earendil-works/pi-ai";
 import { ModelRuntime } from "@earendil-works/pi-coding-agent";
 import { type AuthLayers, type CredentialSourceOptions, type FastagentAuthOptions } from "./auth.ts";
@@ -30,17 +31,29 @@ export interface AgentModels {
     credentials: CredentialStore;
     /**
      * The registry: pi's built-ins, plus (with a directory) the agent's `models.json` and model catalog over the
-     * machine's, plus `providers`. Built on first use and shared after, so a malformed file fails the first reader.
+     * machine's, plus `providers` and extension model declarations. An unbound catalog, built on first use and shared
+     * after; session bindings use createRuntime and their own extension instances.
      */
     runtime(): Promise<ModelRuntime>;
+    /** A session-local registry, before its extensions are loaded. Credentials remain shared. */
+    createRuntime(): Promise<ModelRuntime>;
     /**
      * What authenticates `provider` here, resolved exactly as a turn resolves it: the ONE answer the startup report and a
      * deployed box's `login --if-missing` both give. `modelId` picks the model to probe with; the provider's first one
      * otherwise (auth is provider-scoped).
      */
     authStatus(provider: string, modelId?: string): Promise<AuthStatus>;
+    /**
+     * The definition's extension entry points, discovered once: what this catalog registers models from and what every
+     * session of the assembly built over it loads. Empty without a directory.
+     */
+    extensionPaths(): Promise<readonly string[]>;
 }
 export interface AgentModelsOptions {
+    /** Workspace for extension model registration; defaults to agentDir for standalone definitions. */
+    cwd?: string;
+    /** Where `extensions/` is listed from; Node's filesystem by default. */
+    env?: ExecutionEnv;
     /** Extra providers registered on top of the built-ins (a same id replaces one). */
     providers?: readonly Provider[];
     /**

package/dist/engines/pi/agent-models.js

@@ -1,4 +1,6 @@
 import { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { definitionServices } from "./agent-session-factory.js";
+import { loadExtensionPaths } from "./definition.js";
 import { GLOBAL_AUTH_PATH, assertOneCredentialSource, fastagentCredentialStore, resolveAuthLayers, } from "./auth.js";
 import { createPiModelRuntime, environmentAuthSource, modelRuntimeFiles, piModelsOver, probeAuthSource, } from "./models.js";
 export function agentModels(agentDir, source = {}, options = {}) {
@@ -9,17 +11,40 @@ export function agentModels(agentDir, source = {}, options = {}) {
         : agentDir
             ? resolveAuthLayers(agentDir, source.authPath)
             : { path: source.authPath ?? GLOBAL_AUTH_PATH };
+    // The model files, read once for every runtime this agent builds: a session's and the control plane's.
+    let modelFiles;
+    const readModelFiles = () => (modelFiles ??= modelRuntimeFiles({
+        ...(agentDir ? { agentDir } : {}),
+        ...(machineLayer !== undefined ? { machineLayer } : {}),
+    }));
     const store = files
-        ? agentCredentialStore(files, { agentDir, providers, machineLayer, warn: source.warn })
+        ? agentCredentialStore(files, readModelFiles, { providers, warn: source.warn })
         : undefined;
     const credentials = source.credentialStore ?? store;
+    const createRuntime = async () => createPiModelRuntime({
+        credentials,
+        files: await readModelFiles(),
+        ...(agentDir ? { agentDir } : {}),
+        ...(providers ? { providers } : {}),
+        ...(machineLayer !== undefined ? { machineLayer } : {}),
+    });
+    const cwd = options.cwd ?? agentDir;
+    let discovered;
+    const extensionPaths = () => (discovered ??= agentDir
+        ? loadExtensionPaths(agentDir, { ...(cwd ? { cwd } : {}), ...(options.env ? { env: options.env } : {}) })
+        : Promise.resolve([]));
     let registry;
     const runtime = () => {
-        registry ??= createPiModelRuntime({
-            credentials,
-            ...(agentDir ? { agentDir } : {}),
-            ...(providers ? { providers } : {}),
-            ...(machineLayer !== undefined ? { machineLayer } : {}),
+        registry ??= createRuntime().then(async (models) => {
+            if (agentDir) {
+                await definitionServices({
+                    cwd: cwd ?? agentDir,
+                    modelRuntime: models,
+                    definition: { skills: [] },
+                    extensionPaths: await extensionPaths(),
+                });
+            }
+            return models;
         });
         return registry;
     };
@@ -27,6 +52,8 @@ export function agentModels(agentDir, source = {}, options = {}) {
         ...(files ? { auth: files } : {}),
         credentials,
         runtime,
+        createRuntime,
+        extensionPaths,
         async authStatus(provider, modelId) {
             const models = await runtime();
             const id = modelId ?? models.getProvider(provider)?.getModels()[0]?.id;
@@ -66,7 +93,7 @@ export function createPiModels(options = {}) {
  * there. A deployment never has the global file, so a global login that outranked, say, an `ANTHROPIC_API_KEY` in
  * `.secrets/.env` would run one credential here and a different one deployed.
  */
-function agentCredentialStore(auth, options) {
+function agentCredentialStore(auth, modelFiles, options) {
     const { warn, providers = [] } = options;
     const fallback = auth.fallback;
     if (fallback === undefined)
@@ -76,7 +103,7 @@ function agentCredentialStore(auth, options) {
         project ??= (async () => {
             const runtime = await ModelRuntime.create({
                 credentials: fastagentCredentialStore(auth.path, { warn }),
-                ...(await modelRuntimeFiles(options)).create,
+                ...(await (await modelFiles()).create()),
                 refreshOnCreate: false,
             });
             for (const provider of providers)

package/dist/engines/pi/agent-session-factory.d.ts

@@ -3,7 +3,7 @@ import type { Skill, ThinkingLevel } from "@earendil-works/pi-agent-core";
 import { type AgentSession, type AgentSessionServices, type CompactionResult, type CreateAgentSessionServicesOptions, type ModelRuntime, type ResolvedCommand, SessionManager, createAgentSessionFromServices } from "@earendil-works/pi-coding-agent";
 import type { PiAgentSessionFactory } from "./invoke-session.ts";
 import type { PiSessionRecordStore } from "./session-store.ts";
-import { type MountedTool } from "./tool.ts";
+import type { MountedTool } from "./tool.ts";
 import { type AnyModel } from "./models.ts";
 interface PiSessionDefinition {
     systemPrompt?: string;
@@ -12,11 +12,12 @@ interface PiSessionDefinition {
 export interface PiAgentSessionFactoryOptions {
     /** Where conversations live. */
     sessions: PiSessionRecordStore;
-    /** The model to run and the hub that authenticates it, resolved on FIRST USE and kept. */
+    /** A fresh model runtime per binding: extension routers and provider registrations belong to this session. */
     engine: () => Promise<{
         modelRuntime: ModelRuntime;
-        model: AnyModel;
     }>;
+    /** Resolved after extensions register their models. */
+    modelSpec: string;
     thinkingLevel?: ThinkingLevel;
     tools?: MountedTool[];
     /** Read once per binding; prompt and skills come from the same definition read. */
@@ -42,19 +43,11 @@ export interface BindPiSessionOptions {
     excludedToolNames?: readonly string[];
     /** The CALLER's session id — what a tool asking which conversation it is in hears. */
     sessionId?: string;
-    /** Record each discovered activation on the session, so the next bind restores it. */
-    recordActivations: boolean;
 }
 /**
- * Bind ONE pi session to a record: the definition's tools as pi definitions over one turn context, pi's own tool
- * copies kept off, and deferral applied.
+ * Bind ONE pi session to a record: authored tools replace same-name built-ins; Pi owns exposure and discovery.
  */
 export declare function bindPiSession(options: BindPiSessionOptions): ReturnType<typeof createAgentSessionFromServices>;
-/**
- * Announce extensions pi failed to load. pi collects them into `LoadExtensionsResult.errors` and carries on with the
- * rest.
- */
-export declare function reportExtensionErrors(services: AgentSessionServices): void;
 /** What pi is allowed to discover, minus the parts each assembly fills in itself. */
 type DefinitionLoaderOptions = NonNullable<CreateAgentSessionServicesOptions["resourceLoaderOptions"]>;
 /** The resource posture a fastagent definition asks pi for — ONE definition of it, for both assemblies. */
@@ -81,9 +74,16 @@ export declare function startCompaction(session: AgentSession, instructions: str
     admission: Promise<CompactAdmission>;
     done: Promise<CompactionResult>;
 };
+/** A fresh loader and Pi's native model registration, over a session-local runtime. */
+export declare function definitionServices(options: {
+    cwd: string;
+    modelRuntime: ModelRuntime;
+    definition: PiSessionDefinition;
+    extensionPaths: readonly string[];
+}): Promise<AgentSessionServices>;
 /**
  * The `/name` commands a served session dispatches, named the way pi resolves them (a name two extensions share gets
- * a `:N` suffix). Loaded through the same {@link servingServices} a turn binds, so the menu and the dispatch cannot
+ * a `:N` suffix). Loaded through the same {@link definitionServices} a turn binds, so the menu and the dispatch cannot
  * disagree. Loading runs the extensions' factories; no session opens, so `session_start` does not fire, and the
  * instances are never bound (any action they call throws).
  */