@fastagent-sh/fastagent 0.28.0 → 0.30.0

package/dist/harnesses/pi-durable/open.js

@@ -7,35 +7,33 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 /**
- * A definition assembled onto pi-durable (architecture.md §3): its configuration and generated registry read, its
- * secrets checked as one list, its code built with them, and an Agent opened over pi-ai's built-in models with the
+ * A definition assembled onto pi-durable (architecture.md §3): a source project read as a definition, its secrets
+ * checked as one list, its code built with them, and an Agent opened over pi-ai's built-in models with the
  * text, tools and extensions installed. `dev`, `start` and an embedder call the same function.
  */
 import { existsSync } from "node:fs";
-import { writeFileAtomic } from "../../atomic-write.js";
 import { basename, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { createRegistry, defineExtension, } from "@earendil-works/pi-durable";
-import { NodeExecutionEnv } from "@earendil-works/pi-durable/env/node";
 import { CodingTools } from "@earendil-works/pi-durable/tools";
-import { loadEnvironment } from "../../content/file.js";
 import { describeSecrets, missingSecrets } from "../../declared-secrets.js";
-import { declaredVariables } from "../../environment/declare.js";
-import { channelModuleProblem } from "../../channels/discover.js";
+import { channelIngress, channelModuleProblem } from "../../channels/discover.js";
 import { AGENT_CONFIG_FILE as CONFIG_FILE } from "../../paths.js";
 import { readPackageJson } from "../../runtime.js";
-import { DEV_SERVE_ENV } from "../../serving-command.js";
+import { fastagentVersion } from "../../version.js";
+import { InstanceExecutionEnv } from "./execution-env.js";
+import { instanceName } from "../../instance-name.js";
 import { modelRefOf } from "../../model-ref.js";
 import { MAX_SCHEDULES, scheduleConfigProblem } from "../../schedule/schedule.js";
 import { openDurableAgent } from "./agent.js";
-import { isNeeds } from "./define.js";
-import { GENERATED_DIR, REGISTRY_FILE, REGISTRY_KINDS, generateRegistry } from "./registry.js";
+import { isByIngress, isNeeds } from "./define.js";
+import { checkProgramConfig, devInstanceConfig } from "./config.js";
+import { DEFINITION_FORMAT, chosenIngress, codeSecrets, defineDefinition, } from "./definition.js";
+import { importRegistry } from "./registry.js";
 import { definitionSections, readCommands } from "./text.js";
+import { programText } from "./text-sources.js";
 import { WAKE_EXTENSION, WAKE_TOOLS, wakeExtension } from "./wake.js";
-const SECRETS_MANIFEST_FILE = "secrets.json";
-const CONFIG_KEYS = ["name", "description", "model", "thinkingLevel", "extensions", "providers", "http", "deploy"];
 const DEFINITION_EXTENSION = "fastagent.definition";
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 async function importDefault(path, what) {
     try {
         return (await import(__rewriteRelativeImportExtension(pathToFileURL(path).href))).default;
@@ -44,134 +42,43 @@ async function importDefault(path, what) {
         throw new Error(`${what}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
 }
-/** An object whose keys are among `keys`, or the refusal naming the one that is not and the ones there are. */
-function checkKeys(value, keys, where) {
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        throw new Error(`${where} must be an object`);
-    for (const key of Object.keys(value)) {
-        if (!keys.includes(key))
-            throw new Error(`${where}: unknown key "${key}" (keys: ${keys.join(", ")})`);
-    }
-}
-/** Refuse what a type check would have: Node strips types without checking them, so a typo reaches here. */
-function checkConfig(config, file) {
-    if (config === undefined)
-        return {};
-    if (typeof config !== "object" || config === null || Array.isArray(config)) {
-        throw new Error(`${file} must default-export defineAgent({ ... })`);
-    }
-    checkKeys(config, CONFIG_KEYS, file);
-    const { model, thinkingLevel, extensions, providers, http, deploy } = config;
-    if (http !== undefined) {
-        checkKeys(http, ["port", "api"], `${file}: "http"`);
-        const port = http.port;
-        if (port !== undefined && (!Number.isInteger(port) || port < 0 || port > 65535)) {
-            throw new Error(`${file}: "http.port" must be an integer 0-65535`);
-        }
-        if (http.api !== undefined && typeof http.api !== "boolean") {
-            throw new Error(`${file}: "http.api" must be true or false`);
-        }
-    }
-    if (deploy !== undefined) {
-        checkKeys(deploy, ["agentcore"], `${file}: "deploy"`);
-        if (deploy.agentcore !== undefined) {
-            checkKeys(deploy.agentcore, ["idleTimeoutSeconds"], `${file}: "deploy.agentcore"`);
-            // AWS's own bounds for idleRuntimeSessionTimeout: a value outside them is refused by CloudFormation minutes
-            // into `deploy agentcore --run`, after the image build.
-            const idle = deploy.agentcore.idleTimeoutSeconds;
-            if (idle !== undefined && (!Number.isInteger(idle) || idle < 60 || idle > 1209600)) {
-                throw new Error(`${file}: "deploy.agentcore.idleTimeoutSeconds" must be an integer 60-1209600 (seconds)`);
-            }
-        }
-    }
-    if (model !== undefined)
-        modelRefOf(model, `${file}: "model"`);
-    if (thinkingLevel !== undefined && !THINKING_LEVELS.includes(thinkingLevel)) {
-        throw new Error(`${file}: "thinkingLevel" must be one of ${THINKING_LEVELS.join(", ")}`);
-    }
-    for (const [key, list] of [
-        ["extensions", extensions],
-        ["providers", providers],
-    ]) {
-        if (list !== undefined && !Array.isArray(list))
-            throw new Error(`${file}: "${key}" must be an array`);
-    }
-    return config;
-}
 /** The agent package's `fastagent.config.ts`, checked; `{}` without one. */
-export async function loadConfig(dir) {
+async function loadConfig(dir) {
     const configPath = join(dir, CONFIG_FILE);
-    return checkConfig(existsSync(configPath) ? await importDefault(configPath, CONFIG_FILE) : undefined, CONFIG_FILE);
+    return checkProgramConfig(existsSync(configPath) ? await importDefault(configPath, CONFIG_FILE) : undefined, CONFIG_FILE);
 }
 /** The default model a process here runs with: `--model` > `FASTAGENT_MODEL` > the configuration's `model`. */
 export function modelSpecFor(config, flag, env = process.env) {
     return flag ?? (env.FASTAGENT_MODEL || config.model);
 }
-/** Read the agent package in `dir`: `fastagent.config.ts` (optional) and `.fastagent/registry.ts`, generated first. */
-export async function loadDefinition(directory) {
+/** The development project in `dir`, as `dev` opens it: its source and the `fastagent.json` at its root, if any. */
+export async function loadDevProject(dir) {
+    const definition = await loadSourceDefinition(dir);
+    const instance = await devInstanceConfig(dir);
+    return instance === undefined ? { definition } : { definition, instance };
+}
+/** The source project in `dir` as a definition: `fastagent.config.ts` (optional) and the modules of `src/`. */
+export async function loadSourceDefinition(directory) {
     // Absolute, since the prompt names the definition's files by it and the agent's tools resolve a relative path against
     // the agent's own working directory, which is this one.
     const dir = resolve(directory);
     const config = await loadConfig(dir);
-    const registryPath = join(dir, GENERATED_DIR, REGISTRY_FILE);
-    if (!existsSync(registryPath)) {
-        throw new Error(`${GENERATED_DIR}/${REGISTRY_FILE} is missing: generate it from src/ before opening the agent`);
-    }
-    let registry;
-    try {
-        registry = (await import(__rewriteRelativeImportExtension(pathToFileURL(registryPath).href)));
-    }
-    catch (error) {
-        // The registry imports every module, so a module that fails to load (or has no default export) fails here.
-        throw new Error(`loading src/ through ${GENERATED_DIR}/${REGISTRY_FILE}: ${error.message}`, {
-            cause: error,
-        });
-    }
-    const packageName = (await readPackageJson(dir));
-    const name = config.name ?? (typeof packageName.name === "string" ? packageName.name : basename(dir));
-    return { dir, name, config, registry };
-}
-/** Every value the definition can hold `Needs` in, with where it is: modules by file, configuration by key. */
-function declarers(definition) {
-    return [
-        ...REGISTRY_KINDS.flatMap((kind) => definition.registry[kind].map(({ file, value }) => ({ source: file, value }))),
-        ...(definition.config.extensions ?? []).map((value, i) => ({ source: `${CONFIG_FILE} extensions[${i}]`, value })),
-        ...(definition.config.providers ?? []).map((value, i) => ({ source: `${CONFIG_FILE} providers[${i}]`, value })),
-    ];
-}
-/** The secrets the definition declares, wherever: its code's `needs`, and `context.json`'s command variables. */
-export function definitionSecrets(definition) {
-    return [
-        ...declarers(definition).flatMap(({ source, value }) => isNeeds(value) ? value.secrets.map((secret) => ({ ...secret, source })) : []),
-        ...declaredVariables(loadEnvironment(definition.dir)),
-    ];
-}
-/**
- * The list a person deploying or running the agent reads instead of its code (`.fastagent/secrets.json`): each name
- * once, what it is for, whether the agent runs without it, and where it is declared.
- */
-export function secretsManifest(definition) {
-    const byName = new Map();
-    for (const secret of definitionSecrets(definition)) {
-        const entry = byName.get(secret.name) ?? { name: secret.name, optional: true, declaredIn: [] };
-        entry.optional &&= secret.optional === true;
-        entry.declaredIn.push(secret.source);
-        if (entry.description === undefined && secret.description !== undefined)
-            entry.description = secret.description;
-        byName.set(secret.name, entry);
-    }
-    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-/** Generate the registry, read the definition, and write its secrets manifest beside the registry. */
-export async function prepareDefinition(dir) {
-    await generateRegistry(dir);
-    const definition = await loadDefinition(dir);
-    writeFileAtomic(join(dir, GENERATED_DIR, SECRETS_MANIFEST_FILE), `${JSON.stringify(secretsManifest(definition), null, 2)}\n`, undefined, true);
-    return definition;
+    const registry = await importRegistry(dir);
+    const pkg = (await readPackageJson(dir));
+    return defineDefinition({
+        format: DEFINITION_FORMAT,
+        builtWith: await fastagentVersion(),
+        name: config.name ?? (typeof pkg.name === "string" ? pkg.name : basename(dir)),
+        // A source project need not be published, so it need not have a version.
+        version: typeof pkg.version === "string" ? pkg.version : "0.0.0",
+        dir,
+        config,
+        registry,
+    });
 }
 /** What one value is once its secrets are supplied, or why it is not what its place holds. */
-function built(source, value, values, accept) {
-    const resolved = isNeeds(value) ? value.build(values) : value;
+function built(source, value, values, settings, accept) {
+    const resolved = isNeeds(value) ? value.build(values, settings) : value;
     const problem = accept(resolved);
     if (problem !== undefined)
         throw new Error(`${source}: ${problem}`);
@@ -194,12 +101,38 @@ const channelProblem = channelModuleProblem;
 const scheduleProblem = (value) => value?.kind !== "fastagent.schedule"
     ? "must default-export defineSchedule({ ... }), or needs(...) around one"
     : scheduleConfigProblem(value);
+/**
+ * The channel `name` as `config` has it: the way it chooses of one that receives either way, which must build the
+ * module that way receives with; or the one module there is, which must receive the way `config` names, when it names
+ * one.
+ */
+function chosenChannel(file, name, value, config, build) {
+    const shapeOf = (module) => channelIngress(module) === "webhook" ? "webhook" : "connection";
+    const by = (way) => (way === "webhook" ? "webhook" : "a connection it opens");
+    if (isByIngress(value)) {
+        const way = chosenIngress(config, name);
+        const module = build(value[way], `${file} (byIngress ${way})`);
+        if (shapeOf(module) !== way) {
+            throw new Error(`${file}: its ${way} way builds a channel that receives by ${by(shapeOf(module))}`);
+        }
+        return module;
+    }
+    const module = build(value, file);
+    const named = config.channels?.[name]?.ingress;
+    if (named !== undefined && shapeOf(module) !== named) {
+        throw new Error(`channels.${name}.ingress is "${named}", and ${file} receives only by ${by(shapeOf(module))}: default-export ` +
+            `byIngress({ webhook, connection }) from it to let an instance choose`);
+    }
+    return module;
+}
 /**
  * Refuse to run while a required secret has no value, naming where it is declared; otherwise build every module with
- * the values it declared, and refuse one that is not what its directory holds.
+ * the values it declared, and refuse one that is not what its directory holds. A channel that receives either way is
+ * built the way `config` chooses, and only that way's secrets are asked for.
  */
-export function buildDefinition(definition, env = process.env) {
-    const missing = missingSecrets(definitionSecrets(definition), env);
+export function buildDefinition(definition, env, instance = { settings: {} }) {
+    const { settings } = instance;
+    const missing = missingSecrets(codeSecrets(definition, instance), env);
     if (missing.length > 0) {
         throw new Error(`missing required secrets: ${describeSecrets(missing)} (set them in the environment)`);
     }
@@ -207,27 +140,27 @@ export function buildDefinition(definition, env = process.env) {
     const { registry, config } = definition;
     const tools = registry.tools.map(({ file, value }) => ({
         source: file,
-        ...named(built(file, value, values(value), toolProblem)),
+        ...named(built(file, value, values(value), settings, toolProblem)),
     }));
     const extensions = [
         ...registry.extensions.map(({ file, value }) => ({
             source: file,
-            ...named(built(file, value, values(value), extensionProblem)),
+            ...named(built(file, value, values(value), settings, extensionProblem)),
         })),
         ...(config.extensions ?? []).map((value, i) => {
             const source = `${CONFIG_FILE} extensions[${i}]`;
-            return { source, ...named(built(source, value, values(value), extensionProblem)) };
+            return { source, ...named(built(source, value, values(value), settings, extensionProblem)) };
         }),
     ];
     const channels = registry.channels.map(({ file, name, value }) => ({
         source: file,
         name,
-        value: built(file, value, values(value), channelProblem),
+        value: chosenChannel(file, name, value, instance, (way, source) => built(source, way, values(way), settings, channelProblem)),
     }));
     const schedules = registry.schedules.map(({ file, name, value }) => ({
         source: file,
         name,
-        value: built(file, value, values(value), scheduleProblem),
+        value: built(file, value, values(value), settings, scheduleProblem),
     }));
     refuseTwins("tool", tools);
     // pi-durable replaces an extension installed under a name already taken, its tools and sections with it.
@@ -245,7 +178,7 @@ export function buildDefinition(definition, env = process.env) {
     return {
         tools: tools.map(({ value }) => value),
         extensions: extensions.map(({ value }) => value),
-        providers: (config.providers ?? []).map((value, i) => built(`${CONFIG_FILE} providers[${i}]`, value, values(value), providerProblem)),
+        providers: (config.providers ?? []).map((value, i) => built(`${CONFIG_FILE} providers[${i}]`, value, values(value), settings, providerProblem)),
         channels: new Map(channels.map(({ name, value }) => [name, value])),
         schedules: schedules.map(({ name, value: { kind: _kind, ...config } }) => ({ name, ...config })),
     };
@@ -255,12 +188,15 @@ export function buildDefinition(definition, env = process.env) {
  * providers): a declared secret `env` holds no value for has a stand-in, since the shape must not depend on whether
  * this machine holds the values. Whatever a build refuses, this refuses too.
  */
-export function buildDefinitionShape(definition, env) {
-    const values = Object.fromEntries(definitionSecrets(definition).map(({ name }) => [name, "(no value here)"]));
+export function buildDefinitionShape(definition, env, config = {
+    settings: definition.config.defaults?.settings ?? {},
+    ...(definition.config.defaults?.channels === undefined ? {} : { channels: definition.config.defaults.channels }),
+}) {
+    const values = Object.fromEntries(definition.inputs.secrets.map(({ name }) => [name, "(no value here)"]));
     for (const [name, value] of Object.entries(env))
         if (value)
             values[name] = value;
-    return buildDefinition(definition, values);
+    return buildDefinition(definition, values, config);
 }
 /**
  * The providers of the definition in `agentDir`, for a command that reads models without serving (`models`, `login`,
@@ -268,8 +204,8 @@ export function buildDefinitionShape(definition, env) {
  * it needs no secret the serve would. Without these a provider in code, or one replacing a built-in's id, would be
  * unknown there, or verified against the built-in's endpoint.
  */
-export async function definitionProviders(agentDir, env = process.env) {
-    return buildDefinitionShape(await prepareDefinition(agentDir), env).providers;
+export async function definitionProviders(agentDir, env) {
+    return buildDefinitionShape(await loadSourceDefinition(agentDir), env).providers;
 }
 const named = (value) => ({ name: value.name, value });
 /** Refuse two of a kind under one name: whichever is installed or kept last would silently stand in for the other. */
@@ -284,8 +220,9 @@ function refuseTwins(kind, entries) {
 }
 /** Open the definition as an Agent over `models`: the coding tools, then its own. */
 export async function assembleAgent(definition, options) {
-    const { dir, config } = definition;
-    const { code, models } = options;
+    const { dir } = definition;
+    const { code, models, config } = options;
+    const text = options.text ?? programText(dir);
     const spec = options.model ?? config.model;
     const model = spec === undefined ? undefined : modelRefOf(spec, "the default model");
     if (model !== undefined && models.getModel(model.provider, model.modelId) === undefined) {
@@ -293,13 +230,23 @@ export async function assembleAgent(definition, options) {
         throw new Error(`unknown model "${spec}": no provider "${model.provider}" offers "${model.modelId}"${stale}`);
     }
     const ownWake = [...code.tools, ...code.extensions.flatMap((extension) => extension.tools ?? [])].some(({ name }) => WAKE_TOOLS.includes(name));
+    const authoredNames = new Set([...code.tools, ...code.extensions.flatMap((extension) => extension.tools ?? [])].map((tool) => tool.name));
+    for (const tool of options.mcpTools ?? []) {
+        if (authoredNames.has(tool.name))
+            throw new Error(`MCP tool ${tool.name} conflicts with an authored tool`);
+    }
     const registry = createRegistry();
     registry.install(CodingTools);
     // After the coding tools, so a tool of the definition's own with one of their names replaces it.
     registry.install(defineExtension({
         name: DEFINITION_EXTENSION,
-        sections: definitionSections(dir, options.content ?? [], { wake: ownWake || options.stateRoot !== undefined }),
-        tools: code.tools,
+        sections: definitionSections(dir, options.content ?? [], {
+            wake: ownWake || options.stateRoot !== undefined,
+            runsAs: options.runsAs,
+            workdir: options.workdir ?? dir,
+            text,
+        }),
+        tools: [...code.tools, ...(options.mcpTools ?? [])],
     }));
     for (const extension of code.extensions)
         registry.install(extension);
@@ -311,14 +258,14 @@ export async function assembleAgent(definition, options) {
         storage: options.storage,
         models,
         registry,
-        name: definition.name,
-        ...(config.description === undefined ? {} : { description: config.description }),
+        name: options.name ?? instanceName(definition.name),
+        ...(definition.config.description === undefined ? {} : { description: definition.config.description }),
         ...(model === undefined ? {} : { model }),
         ...(thinkingLevel === undefined ? {} : { thinkingLevel }),
         ...(options.settings === undefined ? {} : { settings: options.settings }),
         ...(options.unfinished === undefined ? {} : { unfinished: options.unfinished }),
         // What the agent runs is not `dev`'s own serving, even when `dev` is what runs the agent.
-        env: ({ cwd }) => new NodeExecutionEnv({ cwd: cwd ?? dir, shellEnv: { ...options.environment, [DEV_SERVE_ENV]: undefined } }),
-        commands: () => readCommands(dir),
+        env: ({ cwd }) => new InstanceExecutionEnv({ cwd: cwd ?? options.workdir ?? dir, processEnv: options.processEnv }),
+        commands: () => readCommands(text),
     });
 }

package/dist/harnesses/pi-durable/reads.d.ts

@@ -24,7 +24,6 @@ export declare function durableReads(harness: Harness, ids: Ids, sessions: Pick<
     message: (record: InputRecord, known?: readonly EntryRecord[]) => Effect.Effect<Message, PortFailure>;
     submission: (messageId: string) => Effect.Effect<InputRecord | undefined, PortFailure, never>;
     submissionByKey: (conversation: Conversation, requestId: string) => Effect.Effect<InputRecord | undefined, PortFailure, never>;
-    inbox: (conversation: Conversation) => Effect.Effect<Readonly<import("@earendil-works/pi-durable").InboxState> | undefined, PortFailure, never>;
     session: (conversation: Pick<Conversation, "id">) => Effect.Effect<Session, PortFailure>;
     sessionsOf: (conversations: readonly ConversationId[]) => Effect.Effect<Session[], PortFailure>;
 };

package/dist/harnesses/pi-durable/reads.js

@@ -1,4 +1,4 @@
-import { AgentDoc, InboxDoc, LiveDoc, UsageDoc, } from "@earendil-works/pi-durable";
+import { AgentDoc, LiveDoc, UsageDoc, } from "@earendil-works/pi-durable";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
@@ -63,7 +63,6 @@ export function durableReads(harness, ids, sessions, context) {
         return port(() => harness.submission(id, context)).pipe(Effect.flatMap((handle) => (handle === undefined ? Effect.undefined : port(() => handle.status(context)))), Effect.map((record) => (isInput(record) ? record : undefined)));
     };
     const submissionByKey = (conversation, requestId) => port(() => harness.commit((tx) => tx.submissionByRequest(conversation.id, requestId), context)).pipe(Effect.map((record) => (isInput(record) ? record : undefined)));
-    const inbox = (conversation) => port(() => harness.snapshot(InboxDoc, conversation.id, context));
     /**
      * The sessions as they are now, in one commit: each one's status, reply and settings of one moment, and a page of
      * them one turn on pi-durable's commit line, which every running session writes through too.
@@ -87,7 +86,6 @@ export function durableReads(harness, ids, sessions, context) {
         message,
         submission,
         submissionByKey,
-        inbox,
         session,
         sessionsOf,
     };

package/dist/harnesses/pi-durable/registry.d.ts

@@ -9,10 +9,8 @@ interface RegisteredModule {
     value: unknown;
 }
 export type Registry = Record<RegistryKind, readonly RegisteredModule[]>;
-export declare const GENERATED_DIR = ".fastagent";
-export declare const REGISTRY_FILE = "registry.ts";
-/** The registry's source: one default import per module, grouped by directory. */
-export declare function registrySource(dir: string): Promise<string>;
-/** Write `.fastagent/registry.ts` for the agent in `dir`, and return its path. */
-export declare function generateRegistry(dir: string): Promise<string>;
+/** The module files of the source project in `dir`, project-relative, in the order the registry imports them. */
+export declare function registryFiles(dir: string): Promise<string[]>;
+/** Import every module of the source project in `dir`, in the order the files sort, so each opens the same way. */
+export declare function importRegistry(dir: string): Promise<Registry>;
 export {};

package/dist/harnesses/pi-durable/registry.js

@@ -1,15 +1,20 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 /**
- * The generated registry (architecture.md §3): `.fastagent/registry.ts`, plain imports of every module in `src/tools/`,
- * `src/extensions/`, `src/channels/` and `src/schedules/`, so nothing is imported by hand, types flow and a bundler can
- * follow it. Each module default-exports one thing; a file directly in the directory is a module, and anything else a
- * module imports (a helper) lives outside these directories. Generated from the files, never edited.
+ * The registry (architecture.md §3): every module in `src/tools/`, `src/extensions/`, `src/channels/` and
+ * `src/schedules/` with what it default-exports, so nothing is imported by hand. A file directly in the directory is a
+ * module, and anything else a module imports (a helper) lives outside these directories.
  */
 import { readdir } from "node:fs/promises";
-import { writeFileAtomic } from "../../atomic-write.js";
 import { join } from "node:path";
+import { pathToFileURL } from "node:url";
 export const REGISTRY_KINDS = ["tools", "extensions", "channels", "schedules"];
-export const GENERATED_DIR = ".fastagent";
-export const REGISTRY_FILE = "registry.ts";
 const MODULE = /^([^.][^/]*)\.(ts|mts|js|mjs)$/;
 const NOT_A_MODULE = /\.(d|test|spec)\.[a-z]+$/;
 /** The module files of one directory of `src/`, sorted so the registry is the same wherever it is generated. */
@@ -30,27 +35,25 @@ async function modulesIn(dir, kind) {
             : [{ file: `src/${kind}/${entry}`, name: match[1] }];
     });
 }
-/** The registry's source: one default import per module, grouped by directory. */
-export async function registrySource(dir) {
-    const lines = ["// Generated by fastagent from src/: do not edit.", ""];
-    const groups = [];
-    let index = 0;
+/** The module files of the source project in `dir`, project-relative, in the order the registry imports them. */
+export async function registryFiles(dir) {
+    return (await Promise.all(REGISTRY_KINDS.map((kind) => modulesIn(dir, kind)))).flatMap((files) => files.map(({ file }) => file));
+}
+/** Import every module of the source project in `dir`, in the order the files sort, so each opens the same way. */
+export async function importRegistry(dir) {
+    const registry = {};
     for (const kind of REGISTRY_KINDS) {
-        const entries = [];
+        registry[kind] = [];
         for (const { file, name } of await modulesIn(dir, kind)) {
-            const local = `m${index++}`;
-            lines.push(`import ${local} from ${JSON.stringify(`../${file}`)};`);
-            entries.push(`  { file: ${JSON.stringify(file)}, name: ${JSON.stringify(name)}, value: ${local} },`);
+            let value;
+            try {
+                value = (await import(__rewriteRelativeImportExtension(pathToFileURL(join(dir, file)).href))).default;
+            }
+            catch (error) {
+                throw new Error(`${file}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+            }
+            registry[kind].push({ file, name, value });
         }
-        groups.push(`export const ${kind} = [\n${entries.join("\n")}${entries.length > 0 ? "\n" : ""}];`);
     }
-    return `${lines.join("\n")}${index > 0 ? "\n" : ""}\n${groups.join("\n\n")}\n`;
-}
-/** Write `.fastagent/registry.ts` for the agent in `dir`, and return its path. */
-export async function generateRegistry(dir) {
-    const path = join(dir, GENERATED_DIR, REGISTRY_FILE);
-    // Every command that reads the definition writes it, `dev`'s worker importing it meanwhile: a reader must see a whole
-    // file, and two writers write the same bytes.
-    writeFileAtomic(path, await registrySource(dir), undefined, true);
-    return path;
+    return registry;
 }

package/dist/harnesses/pi-durable/release.d.ts

@@ -2,8 +2,8 @@
  * Temporary: pi-durable leaves a conversation's queued messages waiting after a run that did not answer (a model
  * failure, an abort, a message sent while an aborted run was still ending) until another submission places them, while
  * the Agent API takes them whatever the message before them ended with (SPEC.md §5.3). A write of FastAgent's own
- * kind places them. pi-durable 1.4.0's `settings.afterFailedRun` covers a model failure (`model_error`, `no_model`)
- * and not an abort: remove this once it does.
+ * kind places them. pi-durable 1.5.0's `settings.afterFailedRun` covers a failed run (a model failure, a crash) and
+ * not an abort: remove this once it does.
  */
 import type { Context } from "@earendil-works/chord/context";
 import { type Harness } from "@earendil-works/pi-durable";

package/dist/harnesses/pi-durable/release.js

@@ -8,15 +8,18 @@ import { queuedInputs } from "./messages.js";
 /** Release every conversation that waits now, and each one a run that did not answer leaves waiting, until the scope closes. */
 export const releaseWaitingQueues = (harness, context) => Effect.gen(function* () {
     const waiting = yield* Queue.unbounded();
-    const unsubscribe = harness.subscribeCommits(({ changes }) => {
-        for (const change of changes) {
-            const record = change.type === "submission" ? change.value : undefined;
-            if (record?.type === "input" && record.status === "unanswered") {
-                Queue.offerUnsafe(waiting, record.conversationId);
+    const observation = harness.observeCommits({
+        advance: ({ changes }) => {
+            for (const change of changes) {
+                const record = change.type === "submission" ? change.value : undefined;
+                if (record?.type === "input" && record.status === "unanswered") {
+                    Queue.offerUnsafe(waiting, record.conversationId);
+                }
             }
-        }
+        },
+        end: () => { },
     });
-    yield* Effect.addFinalizer(() => Effect.sync(unsubscribe));
+    yield* Effect.addFinalizer(() => Effect.sync(() => observation.detach()));
     yield* Queue.take(waiting).pipe(Effect.flatMap((conversationId) => release(harness, conversationId, context).pipe(Effect.catchCause((cause) => Effect.sync(() => log.error(`[fastagent] could not take the messages waiting in conversation ${conversationId}: ${String(portError(cause))}`))))), Effect.forever, Effect.forkScoped);
     const inspection = yield* port(() => harness.inspect(context));
     for (const record of inspection.submissions) {