@fastagent-sh/fastagent 0.24.3 → 0.25.0

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

@@ -1,517 +0,0 @@
-/**
- * The AgentSession L0's engine binding: fastagent's assembled agent — model, prompt, skills, tools — bound to one
- * durable record, per invoke.
- */
-import { dirname } from "node:path";
-import { BUILTIN_EXTENSIONS, DISCOVERY, readMachine, withMachine, } from "./machine.js";
-import { ExtensionRunner, ModelRegistry, SessionManager, createAgentSessionServices, createCodemodeExtension, createToolSearchExtension, createAgentSessionFromServices, createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, getAgentDir, initTheme, } from "@earendil-works/pi-coding-agent";
-import { log } from "../../log.js";
-import { getCurrentSystemMessage } from "@earendil-works/pi-ai";
-import { resolveModel } from "./config.js";
-import { MissingModel, activePath, resolveSessionSettings } from "./session-settings.js";
-import { DEFAULT_THINKING_LEVEL, withModelRegistration } from "./models.js";
-import { registerAccountModels } from "./openai-account-models.js";
-import { asksToEndRun, markEndsRun } from "./turn-kit.js";
-import { agentSessionManager, sessionToolActivation, turnContext } from "./tool-context.js";
-/**
- * What pi's own coding tools say about themselves in its default prompt. The coding tools fastagent mounts are pi's
- * `AgentTool`s, which carry neither field, and they replace pi's definitions of the same name, so without this pi's
- * tool list would lose them and its rules would lose their guidelines.
- */
-const PI_TOOL_PROMPTS = new Map([
-    createReadToolDefinition,
-    createBashToolDefinition,
-    createEditToolDefinition,
-    createWriteToolDefinition,
-    createGrepToolDefinition,
-    createFindToolDefinition,
-    createLsToolDefinition,
-].map((create) => {
-    const definition = create(".");
-    return [
-        definition.name,
-        { promptSnippet: definition.promptSnippet, promptGuidelines: definition.promptGuidelines },
-    ];
-}));
-/**
- * The line pi's default prompt lists a tool by. pi lists only tools that have one; an authored tool's is the first
- * line of its description, so `defineTool` needs no field of its own.
- */
-function promptFields(tool) {
-    const own = tool;
-    const pi = PI_TOOL_PROMPTS.get(tool.name);
-    const promptSnippet = own.promptSnippet ?? pi?.promptSnippet ?? tool.description?.split("\n")[0]?.trim();
-    const promptGuidelines = own.promptGuidelines ?? pi?.promptGuidelines;
-    return {
-        ...(promptSnippet ? { promptSnippet } : {}),
-        ...(promptGuidelines ? { promptGuidelines } : {}),
-    };
-}
-/** fastagent's tools as pi tool definitions, bound to ONE session. */
-function toolDefinitions(tools, bound, sessionId) {
-    return tools.map((tool) => ({
-        ...tool,
-        ...promptFields(tool),
-        label: tool.label || tool.name,
-        execute: (id, params, signal, onUpdate, ctx) => {
-            const binding = bound.current;
-            if (!binding)
-                throw new Error("tool executed before its turn context was bound (lifecycle invariant broken)");
-            const { session, context } = binding;
-            // Expose the caller's id rather than Pi's filename encoding.
-            const sessionManager = Object.create(ctx.sessionManager, {
-                getSessionId: { value: () => sessionId },
-                getHeader: {
-                    value: () => {
-                        const header = ctx.sessionManager.getHeader();
-                        return header ? { ...header, id: sessionId } : header;
-                    },
-                },
-            });
-            // Pi's thinking getter uses a shared runtime; a restored cwd may be a symlink spelling.
-            const scoped = Object.create(ctx, {
-                sessionManager: { value: sessionManager },
-                cwd: { value: context.cwd },
-                thinkingLevel: { get: () => session.thinkingLevel },
-            });
-            return turnContext.run(context, () => tool.execute(id, params, signal, onUpdate, scoped));
-        },
-    }));
-}
-/** The {@link DISCOVERY} tools the mounted tools' exposures need. A disabled extension's name is ignored by Pi. */
-function discoveryToolNames(tools) {
-    const names = new Set();
-    for (const tool of tools) {
-        if (tool.exposure === "codemode" || tool.exposure === "deferred")
-            names.add(DISCOVERY[tool.exposure].tool);
-    }
-    return [...names];
-}
-/**
- * Bind ONE pi session to a record: authored tools replace same-name built-ins; Pi owns exposure and discovery.
- */
-export async function bindPiSession(options) {
-    const { services, sessionManager, model, thinkingLevel, tools, cwd } = options;
-    const excludedToolNames = options.excludedToolNames ?? [];
-    const history = sessionManager.buildSessionContext().messages;
-    const bound = {};
-    const sessionId = options.sessionId ?? sessionManager.getSessionId();
-    const result = await createAgentSessionFromServices({
-        services,
-        sessionManager,
-        ...(options.sessionStartEvent ? { sessionStartEvent: options.sessionStartEvent } : {}),
-        model,
-        thinkingLevel,
-        ...(excludedToolNames.length > 0 ? { excludeTools: [...excludedToolNames] } : {}),
-        customTools: toolDefinitions(tools, bound, sessionId),
-    });
-    const { session } = result;
-    // One context for the whole session: it describes the SESSION, not the call.
-    bound.current = {
-        session,
-        context: {
-            cwd,
-            sessionManager: agentSessionManager(session, sessionId),
-            tools: sessionToolActivation(session),
-        },
-    };
-    // The SDK always supplies an initial loadout (settings' defaultTools applied), bypassing AgentSession's native
-    // transcript restore. The loadout is the definition's defaults as they are NOW, plus whatever the transcript still
-    // declares and is still mounted (a discovery). Removals in the transcript are not honored: fastagent's own activation
-    // only adds, so a removal records a turn on which the definition did not mount the tool, not the conversation's
-    // choice, and honoring it would keep a tool out of a long-lived chat after a release that briefly lacked it.
-    // Replayed through Pi's public APIs, for serving and chat alike.
-    const defaults = [...session.getActiveToolNames(), ...discoveryToolNames(tools)];
-    const current = getCurrentSystemMessage(history);
-    const mounted = new Set(session.getAllTools().map((tool) => tool.name));
-    const declared = (current?.toolsAdded ?? []).map((tool) => tool.name);
-    const dropped = declared.filter((name) => !mounted.has(name));
-    // Debug, not warn: `session_start` handlers register their tools after this point, and Pi activates the
-    // default-active ones when they do (`_refreshToolRegistry`), so an absence here is routine on every such bind.
-    if (dropped.length)
-        log.debug(`[fastagent] session ${sessionId}: not mounted yet or removed: ${dropped.join(", ")}`);
-    session.setActiveToolsByName([...defaults, ...declared.filter((name) => mounted.has(name))]);
-    return result;
-}
-let themeReady = false;
-/** Each distinct load diagnostic is said once per process: serving loads the extensions again for every session. */
-const reportedExtensionDiagnostics = new Set();
-/**
- * Extension notifications said once per process at their own level, then at debug: every served turn starts the
- * extensions again, so a notification from `session_start` would otherwise log the same line on every message.
- */
-const reportedNotifications = new Set();
-// ponytail: cleared wholesale at this size, so a notification with a counter or id in it cannot grow the set for the
-// life of a `start` process; the price is one repeat at warn level after each clear. An LRU if that ever matters.
-const MAX_REPORTED_NOTIFICATIONS = 1000;
-/**
- * Announce extensions pi failed to load, and what it warned about while loading the rest: among them a definition
- * extension that registers `codemode` or `tool_search`, which keeps pi's built-in of that name from loading. pi
- * collects both into `LoadExtensionsResult` and carries on; only its own TUI shows them.
- */
-function reportExtensionDiagnostics(services) {
-    for (const diagnostic of services.diagnostics) {
-        if (diagnostic.type === "error")
-            throw new Error(diagnostic.message);
-    }
-    const { errors, warnings = [] } = services.resourceLoader.getExtensions();
-    const said = [
-        ...errors.map(({ path, error }) => `extension ${path} failed to load: ${error}`),
-        ...warnings.map(({ path, warning }) => `extension ${path}: ${warning}`),
-    ];
-    for (const line of said) {
-        if (reportedExtensionDiagnostics.has(line))
-            continue;
-        reportedExtensionDiagnostics.add(line);
-        log.warn(`[fastagent] ${line}`);
-    }
-}
-/**
- * What a command's `ctx` can do to the session when serving. Each turn binds its own session and disposes it, so
- * there is no current session to replace, fork or reload; pi's unbound default would report `{ cancelled: false }`
- * for all of them without doing anything.
- */
-function servingCommandActions(session) {
-    const unavailable = (action) => async () => {
-        throw new Error(`ctx.${action}() is not available when serving: every turn runs on its own session`);
-    };
-    return {
-        waitForIdle: () => session.waitForIdle(),
-        newSession: unavailable("newSession"),
-        fork: unavailable("fork"),
-        navigateTree: unavailable("navigateTree"),
-        switchSession: unavailable("switchSession"),
-        reload: unavailable("reload"),
-    };
-}
-const nativeFactories = {
-    codemode: createCodemodeExtension(),
-    "tool-search": createToolSearchExtension(),
-};
-const nativeExtensions = BUILTIN_EXTENSIONS.map((name) => ({
-    name,
-    factory: nativeFactories[name],
-    replaceable: true,
-    builtin: true,
-}));
-/**
- * FastAgent's own prompt sections, added on `before_agent_start`: pi renders custom sections after its own, so they
- * survive a `SYSTEM.md` that replaced pi's default, and they stay out of the slot `APPEND_SYSTEM.md` fills.
- */
-function fastagentSections(sections) {
-    return {
-        name: "fastagent-sections",
-        hidden: true,
-        factory: (pi) => {
-            pi.on("before_agent_start", (event) => {
-                Object.assign(event.systemPromptOptions.sections, sections);
-            });
-        },
-    };
-}
-/** The resource posture a fastagent definition asks pi for — ONE definition of it, for both assemblies. */
-export function definitionResourceLoaderOptions(source) {
-    const { definition } = source;
-    return {
-        extensionFactories: [
-            ...nativeExtensions,
-            compactAdmission,
-            recordEndsRun,
-            ...(definition.sections && Object.keys(definition.sections).length > 0
-                ? [fastagentSections(definition.sections)]
-                : []),
-        ],
-        // The machine's extensions are its owner's setup, not this agent's.
-        noExtensions: true,
-        // Explicit paths survive noExtensions, including Pi's built-ins; so they would also survive the machine's own
-        // `-builtin:<name>`, which is why only the enabled ones are named. Machine extensions stay out.
-        additionalExtensionPaths: [
-            ...source.machine.builtinExtensions.map((name) => `builtin:${name}`),
-            ...(source.extensionPaths ?? []),
-        ],
-        // Not pi's discovery: the definition read them (definition.ts), and pi renders what it is handed.
-        noContextFiles: true,
-        agentsFilesOverride: () => ({ agentsFiles: definition.contextFiles ?? [] }),
-        // The IDENTITY is the definition's, whatever the machine thinks: pi's `base` here is the machine's SYSTEM.md, and
-        // it is never used. Inheriting skills is inheriting capability; inheriting a system prompt would be the agent
-        // becoming someone else's agent. Undefined leaves pi to build its default.
-        systemPromptOverride: () => definition.systemPrompt,
-        appendSystemPromptOverride: () => (definition.appendSystemPrompt ? [definition.appendSystemPrompt] : []),
-        /**
-         * THE DEFINITION'S SKILLS, PLUS THE MACHINE'S — an agent inherits the box it runs on (machine.ts), and the
-         * definition wins a name collision.
-         *
-         * NO DISCOVERY OF ITS OWN: the machine's half is the process's single read, so a bound session and `commands()`
-         * describe the same box. A loader discovering for itself is what made the menu live while a session was not.
-         */
-        noSkills: true,
-        skillsOverride: () => ({
-            skills: withMachine(toPiSkills(definition.skills), source.machine.skills),
-            diagnostics: [],
-        }),
-        noPromptTemplates: true,
-        promptsOverride: () => ({
-            prompts: withMachine(toPiPrompts(definition.prompts ?? []), source.machine.prompts),
-            diagnostics: [],
-        }),
-    };
-}
-/**
- * Records on a tool result that it asked to end its run ({@link asksToEndRun}), so `entries()` can tell a run that
- * ended on its tool batch from one cut after its tools. Through pi's `message_end` replacement, which runs before pi
- * appends the message to the record. LAST among the extensions (pi appends inline factories after path ones), so a
- * definition's own `message_end` replacement cannot drop the flag. One instance per loader, so per session.
- */
-const recordEndsRun = {
-    name: "fastagent-record-ends-run",
-    hidden: true,
-    factory: (pi) => {
-        const asked = new Set();
-        pi.on("tool_execution_end", (event) => {
-            if (asksToEndRun(event))
-                asked.add(event.toolCallId);
-        });
-        pi.on("message_end", (event) => {
-            const message = event.message;
-            if (message.role !== "toolResult" || !asked.delete(message.toolCallId))
-                return;
-            return { message: markEndsRun(message) };
-        });
-    },
-};
-/** Manual compactions waiting for pi's admission, keyed by the session's record (what an extension's `ctx` names). */
-const compactAdmissions = new WeakMap();
-const COMPACT_ADMISSION = "fastagent-compact-admission";
-/**
- * pi's own admission signal for a manual compaction: `session_before_compact` fires only once `prepareCompaction`
- * found work, and before the model call. It must be the FIRST listener ({@link admissionFirst}): pi awaits each
- * handler in turn, and a definition's own handler (a custom summarizer, a cancel) runs after admission, like the
- * model call it may replace.
- */
-const compactAdmission = {
-    name: COMPACT_ADMISSION,
-    hidden: true,
-    factory: (pi) => {
-        pi.on("session_before_compact", (event, ctx) => {
-            if (event.reason === "manual")
-                admitCompaction(ctx.sessionManager);
-        });
-    },
-};
-/**
- * pi loads path extensions first and appends inline factories after them, so {@link compactAdmission} arrives last.
- * Moved to the front here, since pi dispatches handlers in extension order.
- */
-function admissionFirst(base) {
-    const path = `<inline:${COMPACT_ADMISSION}>`;
-    const admission = base.extensions.filter((extension) => extension.path === path);
-    return { ...base, extensions: [...admission, ...base.extensions.filter((extension) => extension.path !== path)] };
-}
-/** Tell a waiting {@link startCompaction} that pi admitted the compaction on this record. */
-export function admitCompaction(record) {
-    compactAdmissions.get(record)?.();
-}
-/**
- * pi's refusals when `prepareCompaction` finds nothing. They are plain Errors, so their text is the only way to tell
- * them from any other error pi raises before admission. If pi rewords them, the refusal still fails visibly, as
- * `boundary_command_failed` instead of `nothing_to_compact`, and the admission tests in session-control.test.ts,
- * which run pi's real refusal, fail with it.
- */
-const NOTHING_TO_COMPACT = /^(Nothing to compact|Already compacted)\b/;
-/**
- * Start pi's manual compaction on a bound session. `onAdmitted` runs INSIDE pi's admission event, so everything it
- * publishes precedes anything pi does next (the model call, its retries). `admission` settles before the model call.
- * pi's own pre-admission failures come back as `refused` rather than a rejection: the caller answers them to its
- * Caller as a result. `done` is the compaction itself.
- */
-export function startCompaction(session, instructions, onAdmitted) {
-    const record = session.sessionManager;
-    const admitted = new Promise((resolve) => {
-        compactAdmissions.set(record, () => {
-            try {
-                onAdmitted();
-            }
-            finally {
-                resolve("admitted");
-            }
-        });
-    });
-    const done = session.compact(instructions);
-    const forget = () => void compactAdmissions.delete(record);
-    done.then(forget, forget);
-    const settledFirst = done.then(() => {
-        throw new Error("pi finished a compaction without announcing its admission (session_before_compact)");
-    }, (error) => error instanceof Error && NOTHING_TO_COMPACT.test(error.message) ? "nothing_to_compact" : { refused: error });
-    return { admission: Promise.race([admitted, settledFirst]), done };
-}
-/** A fresh loader and Pi's native model registration, over a session-local runtime. */
-export async function definitionServices(options) {
-    const { cwd, modelRuntime, definition, extensionPaths } = options;
-    const machine = await readMachine(cwd);
-    const services = await withModelRegistration(modelRuntime, () => createAgentSessionServices({
-        cwd,
-        agentDir: getAgentDir(),
-        modelRuntime,
-        settingsManager: machine.settingsManager(),
-        resourceLoaderOptions: {
-            ...definitionResourceLoaderOptions({
-                definition,
-                machine,
-                extensionPaths,
-            }),
-            extensionsOverride: admissionFirst,
-        },
-    }).then((services) => {
-        // AFTER the extensions: one that re-registers `openai` replaced the account-catalog wrapper.
-        registerAccountModels(modelRuntime);
-        return services;
-    }));
-    reportExtensionDiagnostics(services);
-    return services;
-}
-/**
- * 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 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).
- */
-export async function servedExtensionCommands(options) {
-    const services = await definitionServices({ ...options, definition: { skills: [] } });
-    const { extensions, runtime } = services.resourceLoader.getExtensions();
-    const runner = new ExtensionRunner(extensions, runtime, options.cwd, SessionManager.inMemory(options.cwd), new ModelRegistry(options.modelRuntime));
-    return runner.getRegisteredCommands();
-}
-/**
- * Open-or-create the record, then bind a fresh session to it — on a fresh resource loader.
- *
- * ONE LOADER PER SESSION, because pi's extension runtime belongs to its loader: a loader shared across concurrent
- * turns would let one conversation's extension act on another's session. It also makes the definition live with no
- * bookkeeping: every bind reads the prompt and skills this invoke read. The machine's half is the process's one read
- * (machine.ts). Extension CODE is imported once per process, so an edit to `extensions/` needs a restart, which is
- * what `dev` does on one.
- */
-export function piAgentSessionFactory(options) {
-    const { sessions, thinkingLevel, cwd } = options;
-    const extensionPaths = options.extensionPaths ?? [];
-    const excludedToolNames = options.excludedToolNames ?? [];
-    const tools = options.tools ?? [];
-    return async (sessionId, inherit) => {
-        // `ctx.ui.theme` reads pi's global theme, which only pi's own entry points initialize. Serving only: chat's theme
-        // is InteractiveMode's, and resetting it on every session switch would drop the user's.
-        if (!themeReady) {
-            initTheme();
-            themeReady = true;
-        }
-        // Without a default, a turn that cannot run must leave no conversation behind in the listing. A new record with
-        // nothing to inherit records no model, so it is refused before it is created. One that inherits may get a model
-        // from its parent, which only the copy decides (the store's cut), so it is created and, if still model-less,
-        // removed below. The caller holds this session's lease, so nothing else creates the record in between.
-        const existed = options.modelSpec ? true : (await sessions.openIfExists(sessionId)) !== undefined;
-        if (!existed && !inherit)
-            throw new MissingModel(sessionId, []);
-        // Publish the record before loading resources: boundary writes must find it while binding is in flight.
-        const sessionManager = await sessions.openOrCreate(sessionId, inherit);
-        const definition = await options.readDefinition();
-        const { modelRuntime } = await options.engine();
-        const services = await definitionServices({ cwd, modelRuntime, definition, extensionPaths });
-        const model = options.modelSpec ? resolveModel(modelRuntime, options.modelSpec) : undefined;
-        // What the session RUNS on: the boundary plane records model/thinking overrides as entries, and pi does not read
-        // them back.
-        const path = activePath(sessionManager);
-        const settings = resolveSessionSettings(path, modelRuntime, {
-            ...(model ? { model } : {}),
-            thinkingLevel: thinkingLevel ?? DEFAULT_THINKING_LEVEL,
-        });
-        if (!settings) {
-            const missing = new MissingModel(sessionId, path);
-            if (!existed) {
-                // The record this bind created for a thread whose parent supplied no model. A failed removal is reported on
-                // its own and does not replace `missing`: the caller still needs the missing_model answer and its fix.
-                await sessions.delete(sessionId).catch((error) => {
-                    log.warn(`[fastagent] session ${sessionId}: could not remove the record of a refused turn: ${String(error)}`);
-                });
-            }
-            throw missing;
-        }
-        const { session } = await bindPiSession({
-            services,
-            sessionManager,
-            model: settings.model,
-            thinkingLevel: settings.thinkingLevel,
-            tools,
-            cwd,
-            excludedToolNames,
-            sessionId,
-        });
-        // Pi's headless UI drops notifications. Keep dialogs cancelled and hasUI false, but surface diagnostics.
-        const runner = session.extensionRunner;
-        if (runner) {
-            const createContext = runner.createContext.bind(runner);
-            runner.createContext = () => {
-                const context = createContext();
-                // Pi clones own descriptors for before_agent_start; inherited fields would disappear there.
-                return Object.defineProperty(context, "ui", {
-                    value: {
-                        ...context.ui,
-                        notify: (message, type) => {
-                            const key = `${type ?? "info"}\u0000${message}`;
-                            const repeat = reportedNotifications.has(key);
-                            if (reportedNotifications.size >= MAX_REPORTED_NOTIFICATIONS)
-                                reportedNotifications.clear();
-                            reportedNotifications.add(key);
-                            const emit = repeat ? log.debug : type === "info" ? log.info : log.warn;
-                            emit(`[fastagent] session ${sessionId}: ${message}`);
-                        },
-                    },
-                });
-            };
-        }
-        // `onError` is THE ONLY LISTENER for a fault pi reports nowhere else: `/skill:<name>` is expanded by reading
-        // `filePath` at prompt time, and when that read fails pi raises `skill_expansion` on the extension error channel
-        // and sends the line to the model unexpanded. The list can outlive the file: it is refreshed per invoke, so a
-        // steer or follow-up inside a run, or a definition replaced under a running container (`src/deploy/workspace.ts`),
-        // reaches exactly that state. The same channel carries every extension handler's failure.
-        //
-        // No `uiContext`: a served turn has no human at a terminal, and pi's default is what extensions are written to
-        // detect (`ctx.hasUI === false`; dialogs resolve as cancelled). This call fires `session_start`.
-        await session.bindExtensions({
-            onError: ({ extensionPath, event, error }) => log.warn(`[fastagent] session ${sessionId}: ${event} failed for ${extensionPath}: ${error}`),
-            commandContextActions: servingCommandActions(session),
-            shutdownHandler: () => log.warn(`[fastagent] session ${sessionId}: an extension called ctx.shutdown(); a served process is stopped by its host, not by a turn`),
-        });
-        return session;
-    };
-}
-/** The definition's prompt templates as pi's. */
-function toPiPrompts(prompts) {
-    return prompts.map((prompt) => {
-        const baseDir = dirname(prompt.filePath);
-        return {
-            name: prompt.name,
-            description: prompt.description ?? "",
-            content: prompt.content,
-            filePath: prompt.filePath,
-            sourceInfo: { path: prompt.filePath, source: "fastagent", scope: "project", origin: "top-level", baseDir },
-        };
-    });
-}
-/** fastagent's Skill (content inline) as pi's (read from filePath at invocation time). */
-function toPiSkills(skills) {
-    return skills.map((skill) => {
-        const baseDir = dirname(skill.filePath);
-        return {
-            name: skill.name,
-            description: skill.description,
-            filePath: skill.filePath,
-            baseDir,
-            sourceInfo: {
-                path: skill.filePath,
-                source: "fastagent",
-                scope: "project",
-                origin: "top-level",
-                baseDir,
-            },
-            disableModelInvocation: skill.disableModelInvocation ?? false,
-        };
-    });
-}

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

@@ -1,3 +0,0 @@
-import { type BuildSessionRuntimeOptions } from "./session-builder.ts";
-/** Open the workspace's agent in pi's interactive TUI and run until the user exits. */
-export declare function runPiChat(dir: string, options?: BuildSessionRuntimeOptions): Promise<void>;

package/dist/engines/pi/chat.js

@@ -1,8 +0,0 @@
-/** Chat: open a workspace into pi's interactive TUI (`fastagent chat`). */
-import { InteractiveMode } from "@earendil-works/pi-coding-agent";
-import { buildAgentSessionRuntime } from "./session-builder.js";
-/** Open the workspace's agent in pi's interactive TUI and run until the user exits. */
-export async function runPiChat(dir, options = {}) {
-    const runtime = await buildAgentSessionRuntime(dir, options);
-    await new InteractiveMode(runtime, {}).run();
-}

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

@@ -1,71 +0,0 @@
-import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { FastagentTool } from "./tool.ts";
-import type { Models } from "@earendil-works/pi-ai";
-import type { AnyModel } from "./models.ts";
-import type { HttpSurface } from "../../service.ts";
-export interface FastagentConfig {
-    /** "provider/modelId". */
-    model?: string;
-    /** Reasoning effort for the model, pi's scale ("off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max"). */
-    thinkingLevel?: ThinkingLevel;
-    /** Extra custom tools, appended after the pi coding tools — never replaces them. */
-    tools?: FastagentTool[];
-    /** What the serve publishes on its port, and to which browsers (each key is documented on {@link HttpSurface}). */
-    http?: HttpSurface & {
-        /** Default port for `dev` / `start` (`DEFAULT_HTTP_PORT` when unset). */
-        port?: number;
-    };
-    /**
-     * Serve the session control plane over HTTP (`/control/*`: state/entries/events + dispatch — steer/abort/compact +
-     * session properties and lifecycle) for remote consumers.
-     */
-    sessionControl?: boolean;
-    /**
-     * Deploy-time declarations for what the agent needs on the box, so real agents don't hand-write a Dockerfile /
-     * hand-set variables.
-     */
-    deploy?: {
-        /** Extra apt packages baked into the generated image (Debian default repos: git, ripgrep, jq…). */
-        apt?: string[];
-        /** `deploy agentcore` only. */
-        agentcore?: {
-            /**
-             * How long an idle AgentCore session keeps its microVM, 60–1209600 seconds (default 180). Memory bills for the
-             * whole idle tail, and a session past it cold-starts — the workload picks the trade: a chat agent talked to in
-             * bursts wants a longer tail, a schedule-only agent a shorter one.
-             */
-            idleTimeoutSeconds?: number;
-        };
-    };
-}
-/** Identity function for typing and IDE completion (vite/next-style). */
-export declare function defineConfig(config: FastagentConfig): FastagentConfig;
-export interface LoadedConfig {
-    config: FastagentConfig;
-    /** Config file path; undefined when the loader was pointed at a directory holding none. */
-    path?: string;
-}
-export declare function isValidPort(n: number): boolean;
-/** Load `<dir>/fastagent.config.ts`. */
-export declare function loadConfig(dir: string): Promise<LoadedConfig>;
-/** The provider prefix of a "provider/modelId" spec. */
-export declare function providerOf(spec: string): string;
-/** Resolve "provider/modelId" → a pi Model from `models`, so auth resolves from the same collection. */
-export declare function resolveModel(models: Models, spec: string): AnyModel;
-/** All registered "provider/modelId" specs in `models`, sorted — the list behind `fastagent models`. */
-export declare function listModels(models: Models): string[];
-/** Rewrite the `model` in a config file's SOURCE TEXT to `spec`, for the first-run picker's write-back. */
-export declare function rewriteConfigModel(src: string, spec: string): string | null;
-/**
- * Model selection precedence: CLI flag > FASTAGENT_MODEL env > config default. An EMPTY `FASTAGENT_MODEL` is
- * "unset", not "no model": `export FASTAGENT_MODEL=` in a shell or CI job, and an `environment:`/`env` entry that
- * interpolates a missing variable, both arrive as `""` — and a set-but-empty value that shadowed `config.model`
- * would refuse to start an agent whose config names a model.
- */
-export declare function resolveModelSpec(flag: string | undefined, config: FastagentConfig, env?: NodeJS.ProcessEnv): string | undefined;
-/**
- * The refusal of a process that runs the agent here (the CLI's dev/start/invoke/routine run, and chat) when no
- * default model resolves. The agent itself opens without one; such a process would fail every new conversation, so it
- * stops at startup instead.
- */
-export declare function missingDefaultModel(): Error;