@fastagent-sh/fastagent 0.24.4 → 0.26.0

package/dist/channels/slack/context-buffer.js

@@ -1,37 +0,0 @@
-/**
- * Slack's half of the shared context buffer (mechanics + consume protocol: ../kit/context-buffer.ts): the entry shape,
- * its fold-line rendering, and buffered-file selection.
- */
-import { capBufferedRefs, createContextBuffer as createGenericContextBuffer, } from "../kit/context-buffer.js";
-function bufferLine(entry) {
-    const meta = [`msg ${entry.messageId}`, entry.replyTo ? `thread root ${entry.replyTo}` : undefined]
-        .filter(Boolean)
-        .join(", ");
-    return `${entry.sender} (${meta}): ${entry.body}`;
-}
-export function collectSlackBufferedFiles(consumed, primaryIds) {
-    const seen = new Set();
-    const files = [];
-    for (const entry of consumed) {
-        for (const id of entry.fileIds ?? []) {
-            if (primaryIds.has(id) || seen.has(id))
-                continue;
-            seen.add(id);
-            files.push({ id, from: entry.sender, messageId: entry.messageId });
-        }
-    }
-    const capped = capBufferedRefs(files);
-    return { files: capped.kept, skipped: capped.skipped };
-}
-function isEntry(value) {
-    const entry = value;
-    return (typeof entry?.sender === "string" &&
-        typeof entry.body === "string" &&
-        typeof entry.messageId === "string" &&
-        (entry.replyTo === undefined || typeof entry.replyTo === "string") &&
-        (entry.fileIds === undefined ||
-            (Array.isArray(entry.fileIds) && entry.fileIds.every((id) => typeof id === "string"))));
-}
-export function createSlackContextBuffer(path, label) {
-    return createGenericContextBuffer({ path, label, isEntry, line: bufferLine });
-}

package/dist/channels/sse.d.ts

@@ -1,4 +0,0 @@
-/** Shared SSE response lifecycle for invoke and session observation. */
-/** The remote client's idle watchdog allows three missed heartbeats. */
-export declare const SSE_HEARTBEAT_MS = 30000;
-export declare function sseResponse<T>(events: AsyncIterable<T>, project?: (event: T) => unknown): Response;

package/dist/channels/sse.js

@@ -1,66 +0,0 @@
-/** Shared SSE response lifecycle for invoke and session observation. */
-/** The remote client's idle watchdog allows three missed heartbeats. */
-export const SSE_HEARTBEAT_MS = 30_000;
-const encoder = new TextEncoder();
-const heartbeat = encoder.encode(": ping\n\n");
-export function sseResponse(events, project = (event) => event) {
-    const iterator = events[Symbol.asyncIterator]();
-    // Subscribe before headers; synchronous startup errors belong to the HTTP error boundary.
-    let pending = Promise.resolve(iterator.next());
-    // pull() surfaces asynchronous failures. Observe rejection even if the caller cancels before that pull.
-    pending.catch(() => { });
-    let closed = false;
-    let timer;
-    const stop = () => {
-        closed = true;
-        clearInterval(timer);
-    };
-    const cancel = async () => {
-        if (closed)
-            return;
-        stop();
-        await iterator.return?.();
-    };
-    const stream = new ReadableStream({
-        start(controller) {
-            timer = setInterval(() => controller.enqueue(heartbeat), SSE_HEARTBEAT_MS);
-        },
-        async pull(controller) {
-            try {
-                const next = await (pending ?? iterator.next());
-                pending = undefined;
-                // Cancellation can settle a pending next(); its value no longer has a reader.
-                if (closed)
-                    return;
-                if (next.done) {
-                    stop();
-                    controller.close();
-                }
-                else {
-                    controller.enqueue(encoder.encode(`data: ${JSON.stringify(project(next.value))}\n\n`));
-                }
-            }
-            catch (error) {
-                if (closed)
-                    return;
-                // Errored streams never call cancel(), so iterator and timer cleanup belongs here too.
-                try {
-                    await cancel();
-                }
-                catch (cleanupError) {
-                    controller.error(new AggregateError([error, cleanupError], "SSE source and cleanup failed", { cause: error }));
-                    return;
-                }
-                controller.error(error);
-            }
-        },
-        cancel,
-    });
-    return new Response(stream, {
-        headers: {
-            "content-type": "text/event-stream",
-            "cache-control": "no-cache",
-            connection: "keep-alive",
-        },
-    });
-}

package/dist/cli/commands/chat.d.ts

@@ -1,3 +0,0 @@
-export declare function runChat(dirArg: string, opts: {
-    model?: string;
-}): Promise<void>;

package/dist/cli/commands/chat.js

@@ -1,14 +0,0 @@
-/** `fastagent chat [dir]`: open the SAME assembled agent in pi's interactive TUI. */
-import { failStartup } from "../fail.js";
-import { enterAgentCommand } from "../shared.js";
-export async function runChat(dirArg, opts) {
-    // Chat authenticates through fastagent's credential store like every other command (the shared session builder
-    // injects it — see engines/pi/session-builder.ts), so the first-run picker and its inline login apply here too.
-    const placement = await enterAgentCommand(dirArg, opts);
-    // Run the chat process AT the workspace: pi resolves a session's cwd as `header.cwd ?? process.cwd()`, so aligning
-    // process.cwd() with the workspace keeps a cwd-less session on it.
-    process.chdir(placement.workspace);
-    // Lazy-import: chat pulls pi's interactive TUI module graph; headless start/dev never need it.
-    const { runPiChat } = await import("../../engines/pi/chat.js");
-    await runPiChat(placement.agentDir, { model: placement.modelSpec }).catch(failStartup);
-}

package/dist/cli/commands/routine-run.d.ts

@@ -1,6 +0,0 @@
-export interface RoutineRunOptions {
-    model?: string;
-    /** false ⇔ `--no-input`. */
-    input?: boolean;
-}
-export declare function runRoutine(name: string, dirArg: string, opts: RoutineRunOptions): Promise<void>;

package/dist/cli/commands/routine-run.js

@@ -1,46 +0,0 @@
-/**
- * `fastagent routine run <name> [dir]`: run ONE routine's turn immediately — the authoring loop for routines (like
- * `invoke` is for a prompt). Cron or not: a routine that declares none has no other local entry.
- */
-import { join } from "node:path";
-import { displayPath } from "../../paths.js";
-import { reportModuleLoadFailures } from "../../loader.js";
-import { createPiAgentFromDir } from "../../engines/pi/open.js";
-import { runInvokeStream } from "../invoke-stream.js";
-import { loadRoutines } from "../../schedule/discover.js";
-import { routineSession } from "../../schedule/routine.js";
-import { failStartup, gateSecretsOrExit } from "../fail.js";
-import { enterAgentDirectory, reportAuth, requireDefaultModel } from "../shared.js";
-export async function runRoutine(name, dirArg, opts) {
-    const placement = await enterAgentDirectory(dirArg, opts);
-    // Routines are agent surface — discovered where dev/start/`routine list` do (the agent dir), so this command
-    // sees the same set the clock serves.
-    const { routines, secrets, failures } = await loadRoutines(placement.agentDir).catch(failStartup);
-    // Reported BEFORE the name is looked up: a routine file that failed to import is missing from
-    // `routines`, so "unknown routine" is the case where the author most needs to hear about it.
-    reportModuleLoadFailures(failures);
-    const routine = routines.find((r) => r.name === name);
-    if (!routine) {
-        // Name the discovery path: a schedule misplaced in the workspace (outside the agent dir) should read as "wrong
-        // place", not "broken file".
-        failStartup(new Error(`unknown routine "${name}" (looked in ${displayPath(process.cwd(), join(placement.agentDir, "routines")) ?? "routines"}). ` +
-            `available: ${routines.map((r) => r.name).join(", ") || "(none)"}`));
-    }
-    // This RUNS the routine, so it takes the serving path's guarantee: a prompt built from an
-    // unset declared value is the degraded turn this feature exists to prevent (`Post the digest to `
-    // — sent and executed), and the loader resolved it into a string before anything could notice.
-    // THIS schedule only (`owner`): running one routine must not fail because a SIBLING ROUTINE needs a
-    // credential this machine has no reason to hold. The agent assembled below is a different question
-    // and gates every mounted tool — a run's turn can call any of them — so this command is not free of a
-    // tool's declaration, only of another routine's. The failures go to the gate too, even though they
-    // were printed above: its guarantee must not depend on this call site remembering (a repeated line
-    // on the refusal path is the cheaper failure).
-    gateSecretsOrExit({ declared: secrets, failures, owner: name });
-    const { modelSpec } = requireDefaultModel(placement);
-    const { agent, models } = await createPiAgentFromDir(placement.agentDir, { model: modelSpec }).catch(failStartup);
-    console.error(`[fastagent] routine run: ${name} (${modelSpec})`);
-    await reportAuth(models, modelSpec);
-    const exitCode = await runInvokeStream(agent.invoke({ session: routineSession(name) }, { text: routine.prompt }), (text) => process.stdout.write(text), (line) => console.error(line));
-    process.stdout.write("\n");
-    process.exit(exitCode);
-}

package/dist/cli/commands/routine.d.ts

@@ -1,25 +0,0 @@
-/**
- * `fastagent routine history <name> [dir]`: print this routine's fired slots — when each fired, how it ended, how
- * long it took.
- *
- * The history IS the claims (`schedule/claims/<name>/`), so it is bounded by construction and carries no turn text:
- * what the run SAID is in its session (`routine:<name>`), stored once, like any other turn's, under the state
- * root's `sessions/` — which is where this command points rather than copying any of it here.
- *
- * This command does NOT try to say which turn belongs to which fire. Nothing links them: a routine's fires share
- * ONE continuing conversation, so the session id is the same for all of them, and the turn-level identifier would
- * have to cross the engine-neutral contract (no `AgentEvent` carries an entry id) or cost the shared conversation.
- * A claim's timestamp against a time-ordered journal is what an operator reads anyway — matching them HERE only
- * moves a human's judgement into a heuristic that cannot be right about a session other writers also append to.
- */
-export declare function runRoutineHistory(name: string, dirArg: string, json: boolean): void;
-/**
- * `fastagent routine list [dir]`: every declared routine, and when (or whether) a clock fires it.
- *
- * IT ALSO READS the agent's pending wake-ups. They are a different owner (the state, not the definition) but the
- * same question when an operator is asking it: "what is going to wake this agent up?". Deleting the command that
- * CANCELLED one was right — `unwake({ id })` covers it, and a serve that can receive the alarm can also be spoken
- * to — but that argument is about WRITING. Without a read, the only way to learn why an agent wakes at 3am is to
- * open `<stateRoot>/schedule/wakeups.json` by hand.
- */
-export declare function runRoutineList(dirArg: string, json: boolean): Promise<void>;

package/dist/cli/commands/routine.js

@@ -1,122 +0,0 @@
-/**
- * `fastagent routine history|list` — the routines this DEFINITION declares.
- *
- * The agent's own pending wake-ups are not here and have no command: they live in the state, not the definition,
- * and `unwake({ id })` is what cancels one (schedule/wakeups.ts says why).
- */
-import { resolve } from "node:path";
-import { enterAgentEnv } from "../../env.js";
-import { resolveSessionsDir, resolveStateRoot } from "../../paths.js";
-import { reportModuleLoadFailures } from "../../loader.js";
-import { nextRun } from "../../schedule/cron.js";
-import { loadRoutines } from "../../schedule/discover.js";
-import { routineSession } from "../../schedule/routine.js";
-import { isSafeScheduleName, readFires } from "../../schedule/state.js";
-import { listWakeups } from "../../schedule/wakeups.js";
-import { failStartup, placementOrExit } from "../fail.js";
-/**
- * `fastagent routine history <name> [dir]`: print this routine's fired slots — when each fired, how it ended, how
- * long it took.
- *
- * The history IS the claims (`schedule/claims/<name>/`), so it is bounded by construction and carries no turn text:
- * what the run SAID is in its session (`routine:<name>`), stored once, like any other turn's, under the state
- * root's `sessions/` — which is where this command points rather than copying any of it here.
- *
- * This command does NOT try to say which turn belongs to which fire. Nothing links them: a routine's fires share
- * ONE continuing conversation, so the session id is the same for all of them, and the turn-level identifier would
- * have to cross the engine-neutral contract (no `AgentEvent` carries an entry id) or cost the shared conversation.
- * A claim's timestamp against a time-ordered journal is what an operator reads anyway — matching them HERE only
- * moves a human's judgement into a heuristic that cannot be right about a session other writers also append to.
- */
-export function runRoutineHistory(name, dirArg, json) {
-    const { agentDir: target } = placementOrExit(resolve(dirArg));
-    enterAgentEnv(target); // FASTAGENT_STATE_DIR may live in .env — read the SAME state root the scheduler wrote
-    const stateRoot = resolveStateRoot(target);
-    // A name that cannot be a routine is a MISTYPED ARGUMENT, and it must not look like an empty history: exit 1 the
-    // way every other user-input refusal does, so `--json` printing nothing is never read as "the command succeeded".
-    if (!isSafeScheduleName(name)) {
-        failStartup(new Error(`"${name}" cannot be a routine name (no path separators, "." or "..")`));
-    }
-    // `readFires` throws a raw fs error on unreadable state, because its other caller is the serving boot, which must
-    // fail rather than arm a schedule it cannot read. This caller is a read-only CLI command: the same fact is an
-    // operator's to fix, so it exits the way every other refusal in this file does instead of printing a Node stack.
-    let fires;
-    try {
-        fires = readFires(stateRoot, name);
-    }
-    catch (e) {
-        failStartup(new Error(`the fired-slot claims for "${name}" are unreadable (state: ${stateRoot}): ${String(e)}`));
-    }
-    if (json) {
-        console.log(JSON.stringify(fires, null, 2));
-        return;
-    }
-    if (fires.length === 0) {
-        // No special case for "wake": it is an ordinary schedule name now (`discover.ts` stopped reserving it).
-        console.error(`no recorded fires for "${name}" (state: ${stateRoot})`);
-        return;
-    }
-    // The question is "did LAST NIGHT's run fail?", so text mode tails the most recent fires; --json above is the
-    // whole retained window.
-    const TAIL = 20;
-    const shown = fires.slice(-TAIL);
-    for (const f of shown) {
-        // An unreported fire has no duration to print, and `0ms` would be a value a fast turn really produces — the
-        // column stays empty rather than claiming the turn took no time.
-        const took = f.ms === undefined ? "" : `${f.ms}ms`;
-        console.log(`${f.firedAt}  ${(f.outcome ?? "unreported").padEnd(11)} ${took.padStart(8)}`);
-    }
-    if (fires.length > shown.length) {
-        console.error(`(the last ${shown.length} of ${fires.length} fires — --json for all)`);
-    }
-    // The other half of the answer, and where it lives: these rows say a fire happened, not what it produced. The
-    // session id comes from the ONE place that spells it and the directory from the ONE place that resolves it. The
-    // record is one level further down and under a name pi accepts (`piSessionId` escapes the `:`), so the pointer
-    // says how to recognise the file rather than claiming a path the reader can paste.
-    console.error(`(what these runs said: session ${routineSession(name)} — a JSON-lines journal under ${resolveSessionsDir(target)}, ` +
-        `in the file whose name carries "${name}")`);
-}
-/**
- * `fastagent routine list [dir]`: every declared routine, and when (or whether) a clock fires it.
- *
- * IT ALSO READS the agent's pending wake-ups. They are a different owner (the state, not the definition) but the
- * same question when an operator is asking it: "what is going to wake this agent up?". Deleting the command that
- * CANCELLED one was right — `unwake({ id })` covers it, and a serve that can receive the alarm can also be spoken
- * to — but that argument is about WRITING. Without a read, the only way to learn why an agent wakes at 3am is to
- * open `<stateRoot>/schedule/wakeups.json` by hand.
- */
-export async function runRoutineList(dirArg, json) {
-    const { agentDir: target } = placementOrExit(resolve(dirArg));
-    enterAgentEnv(target);
-    const { routines, failures } = await loadRoutines(target).catch(failStartup);
-    reportModuleLoadFailures(failures);
-    const wakeups = listWakeups(resolveStateRoot(target));
-    if (json) {
-        console.log(JSON.stringify({
-            routines: routines.map((r) => ({
-                ...r,
-                next: r.cron === undefined ? null : (nextRun(r.cron, r.tz, new Date())?.toISOString() ?? null),
-            })),
-            wakeups,
-        }, null, 2));
-        return;
-    }
-    if (routines.length === 0 && wakeups.length === 0) {
-        console.error(`nothing declared or pending — no routines/ files, no wake-ups (agent: ${target})`);
-        return;
-    }
-    for (const r of routines) {
-        // A routine with no cron is not broken and not idle: it is reached by NAME (`routine run`, `POST /run`), and
-        // saying "on demand" is the difference between that and a cron that will never fire again.
-        const when = r.cron === undefined
-            ? "on demand".padEnd(26)
-            : `${(nextRun(r.cron, r.tz, new Date())?.toISOString() ?? "(never)").padEnd(26)}cron ${r.cron}${r.tz ? ` ${r.tz}` : ""}`;
-        console.log(`${r.name.padEnd(20)} ${when}`);
-    }
-    // Labelled, because these two are NOT the same kind of thing: a routine is the author's, a wake-up is the
-    // agent's own and is cancelled with `unwake` rather than a command here.
-    for (const w of wakeups) {
-        const kind = w.cron ? `cron ${w.cron}${w.tz ? ` ${w.tz}` : ""}` : "one-shot";
-        console.log(`wake ${w.id}  ${w.fireAt}  ${kind}  session=${w.session}  ${w.prompt.slice(0, 60)}`);
-    }
-}

package/dist/cli/commands/tool.d.ts

@@ -1 +0,0 @@
-export declare function runTool(name: string, argsJson: string, dirArg: string): Promise<void>;

package/dist/cli/commands/tool.js

@@ -1,57 +0,0 @@
-/** `fastagent tool <name> '<json>' [dir]`: run one tool's body directly with JSON args — no model. */
-import { resolve } from "node:path";
-import { enterAgentEnv } from "../../env.js";
-import { loadConfig } from "../../engines/pi/config.js";
-import { resolveAgentTools } from "../../engines/pi/create.js";
-import { reportModuleLoadFailures } from "../../loader.js";
-import { turnContext } from "../../engines/pi/tool-context.js";
-import { failStartup, failUsage, gateSecretsOrExit, placementOrExit } from "../fail.js";
-export async function runTool(name, argsJson, dirArg) {
-    // Argument shape first: malformed JSON is a USAGE error (exit 2), independent of whether the directory is an agent
-    // (a runtime failure, exit 1).
-    const args = parseToolArgs(argsJson);
-    const { agentDir, workspace } = placementOrExit(resolve(dirArg));
-    enterAgentEnv(agentDir); // a tool may read a key from .env — and fetch through the proxy it declares
-    const { config } = await loadConfig(agentDir).catch(failStartup);
-    // The same tool set dev/start mount (all coding tools + config.tools + discovered, deduped), so the runner
-    // exercises exactly what gets served.
-    const { tools, toolCollisions, toolFailures, toolSecrets } = await resolveAgentTools(config, agentDir, workspace).catch(failStartup);
-    for (const c of toolCollisions) {
-        console.error(`[fastagent] warn: tool "${c.name}" (${c.source}) is shadowed by a default/config tool — not mounted`);
-    }
-    // Reported BEFORE the name is looked up: a file that failed to import is missing from `tools`, so
-    // "unknown tool" is exactly the case where the author most needs to hear that something blew up
-    // rather than that they mistyped it.
-    reportModuleLoadFailures(toolFailures);
-    const tool = tools.find((t) => t.name === name);
-    if (!tool) {
-        failStartup(new Error(`unknown tool "${name}". available: ${tools.map((t) => t.name).join(", ") || "(none)"}`));
-    }
-    // This command RUNS one tool body, so it takes the same guarantee dev/start take — for THAT tool
-    // only (`owner`): running one tool by hand must not require the credentials of the tools it is not
-    // running, and `routine run` scopes the same way for one routine.
-    // The failures go to the gate as well, even though they were just printed: the gate's guarantee is
-    // that a refusal never hides them, and it cannot know a caller already reported. A repeated line on
-    // the refusal path is the cheaper failure than one that depends on this call site remembering.
-    gateSecretsOrExit({ declared: toolSecrets, failures: toolFailures, owner: name });
-    // Authored tools read cwd from turnContext; coding tools are already rooted at the workspace.
-    const result = await turnContext.run({ cwd: workspace }, () => tool.execute(`cli-${name}`, args)).catch(failStartup);
-    // What the MODEL receives, which is not what is printed below: the printed form is `details` (readable, indented),
-    // the model's is the content text (compact JSON). Piping stdout through `wc -c` therefore answers the wrong
-    // question, and there is nowhere else to ask this one — so the run that a tool author already does reports it.
-    const modelText = (result?.content ?? []).map((c) => ("text" in c ? c.text : "")).join("");
-    const out = result?.details !== undefined ? result.details : modelText;
-    console.log(typeof out === "string" ? out : JSON.stringify(out, null, 2)); // stdout stays DATA
-    // No threshold warning: context windows run from 128k to 1M, so any fixed ceiling here would be invented. The
-    // number is the signal; docs/api-reference.md carries the judgement. ~4 chars/token is the usual rough figure.
-    console.error(`[fastagent] result: ${modelText.length} chars ≈ ${Math.ceil(modelText.length / 4)} tokens to the model`);
-}
-/** Parse the CLI's JSON args blob; malformed input syntax is a usage error (exit 2). */
-function parseToolArgs(argsJson) {
-    try {
-        return JSON.parse(argsJson);
-    }
-    catch {
-        failUsage(`invalid JSON args: ${argsJson}`);
-    }
-}

package/dist/collect.d.ts

@@ -1,63 +0,0 @@
-/**
- * Stream helpers around the SPEC's two stream disciplines.
- *
- * Caller side: `collect` (buffered consumption, SPEC §7) reduces an AgentEvent stream to a final
- * value, encoding the terminal discipline (failed → throw, missing terminal → error) — streaming
- * consumers for-await themselves.
- *
- * Agent side: the cancellation protocol (SPEC MUST 3), in two halves that only work together —
- * `abortFirstIterator` delivers the consumer's knock, `cancellableStream` is what an engine wraps
- * its turn in to receive it.
- */
-import type { AgentEvent, Json } from "./agent.ts";
-/**
- * The abort-first cancellation protocol, ONCE: an async generator suspended on a quiet await (a
- * tool mid-execution, a silent SSE read) parks inside that await, and `gen.return()`/`gen.throw()`
- * queue behind the pending `next()` FOREVER (async-generator semantics) — a consumer's cancel
- * would deadlock. The wrapper's `return()` first runs `cancel` (abort the underlying work, which
- * settles the suspension), then delegates to `gen.return`, swallowing its rejection (the
- * generator's own catch/finally already surfaced the outcome). `throw()` tears down identically
- * and rethrows the caller's error deterministically instead of poking a completed generator.
- *
- * NOT `Stream.toAsyncIterable`. Its `return()` does interrupt the in-flight pull and close the scope,
- * but a pull that has ALREADY resolved still hands its value back from the same `next()` — the entry
- * guard only catches later calls. A consumer that cancels while a buffered terminal is in flight would
- * therefore receive that terminal, which is the one thing MUST 3 forbids. The re-check after the await
- * below is what makes the silence deterministic instead of a race.
- *
- * Cancellation also SILENCES the stream, and that belongs here rather than in each producer: a
- * generator parked in an await can still reach a `yield` on its way out (an error path that
- * yields a terminal, say), and that yield satisfies the pending `next()` — handing a terminal
- * event to a consumer that already walked away, which SPEC MUST 3 forbids. Deciding it once, at
- * the protocol boundary, is what keeps every producer from having to re-ask "is anyone still
- * listening?" before each yield.
- */
-export declare function abortFirstIterator<T>(gen: AsyncGenerator<T>, cancel: () => void): AsyncIterator<T>;
-/** What a turn generator gets so a consumer walking away can stop it. */
-export interface CancelHooks {
-    /** Publish the door: how to abort the engine work, once there is engine work to abort. */
-    onCancelReady: (cancel: () => void) => void;
-    /** The latch, for the window where the door is armed but the engine is still idle — knocking then
-     *  does nothing, so a turn must read this before committing to work no one is waiting for. */
-    wasCancelled: () => boolean;
-}
-/**
- * Wrap a turn generator in the cancellation protocol: cancelling the returned stream latches the
- * intent AND knocks on whatever door the generator published, in that order (the latch must be set
- * before the knock, or a turn checking it mid-flight could miss the cancel it just received).
- */
-export declare function cancellableStream<T>(start: (hooks: CancelHooks) => AsyncGenerator<T>): AsyncIterable<T>;
-/** Exception form of a failed event (thrown by collect). Carries the failed event's fields verbatim, so
- *  a buffered consumer can branch on `code` (SPEC §8 failure subdivision) just like a streaming one. */
-export declare class AgentFailure extends Error {
-    readonly details: string;
-    readonly retryable: boolean;
-    /** Machine-readable failure subdivision (SPEC §8), when the engine set one. */
-    readonly code?: string;
-    constructor(details: string, retryable: boolean, code?: string);
-}
-export interface CollectResult {
-    text: string;
-    data?: Json;
-}
-export declare function collect(events: AsyncIterable<AgentEvent>): Promise<CollectResult>;

package/dist/collect.js

@@ -1,90 +0,0 @@
-/**
- * The abort-first cancellation protocol, ONCE: an async generator suspended on a quiet await (a
- * tool mid-execution, a silent SSE read) parks inside that await, and `gen.return()`/`gen.throw()`
- * queue behind the pending `next()` FOREVER (async-generator semantics) — a consumer's cancel
- * would deadlock. The wrapper's `return()` first runs `cancel` (abort the underlying work, which
- * settles the suspension), then delegates to `gen.return`, swallowing its rejection (the
- * generator's own catch/finally already surfaced the outcome). `throw()` tears down identically
- * and rethrows the caller's error deterministically instead of poking a completed generator.
- *
- * NOT `Stream.toAsyncIterable`. Its `return()` does interrupt the in-flight pull and close the scope,
- * but a pull that has ALREADY resolved still hands its value back from the same `next()` — the entry
- * guard only catches later calls. A consumer that cancels while a buffered terminal is in flight would
- * therefore receive that terminal, which is the one thing MUST 3 forbids. The re-check after the await
- * below is what makes the silence deterministic instead of a race.
- *
- * Cancellation also SILENCES the stream, and that belongs here rather than in each producer: a
- * generator parked in an await can still reach a `yield` on its way out (an error path that
- * yields a terminal, say), and that yield satisfies the pending `next()` — handing a terminal
- * event to a consumer that already walked away, which SPEC MUST 3 forbids. Deciding it once, at
- * the protocol boundary, is what keeps every producer from having to re-ask "is anyone still
- * listening?" before each yield.
- */
-export function abortFirstIterator(gen, cancel) {
-    let cancelled = false;
-    const teardown = async () => {
-        cancelled = true;
-        cancel();
-        await gen.return(undefined).catch(() => { });
-    };
-    return {
-        async next() {
-            const result = await gen.next();
-            return cancelled ? { done: true, value: undefined } : result;
-        },
-        async return() {
-            await teardown();
-            return { done: true, value: undefined };
-        },
-        async throw(error) {
-            await teardown();
-            throw error;
-        },
-    };
-}
-/**
- * Wrap a turn generator in the cancellation protocol: cancelling the returned stream latches the
- * intent AND knocks on whatever door the generator published, in that order (the latch must be set
- * before the knock, or a turn checking it mid-flight could miss the cancel it just received).
- */
-export function cancellableStream(start) {
-    let door;
-    let cancelled = false;
-    const iterator = abortFirstIterator(start({
-        onCancelReady: (cancel) => {
-            door = cancel;
-        },
-        wasCancelled: () => cancelled,
-    }), () => {
-        cancelled = true;
-        door?.();
-    });
-    return { [Symbol.asyncIterator]: () => iterator };
-}
-/** Exception form of a failed event (thrown by collect). Carries the failed event's fields verbatim, so
- *  a buffered consumer can branch on `code` (SPEC §8 failure subdivision) just like a streaming one. */
-export class AgentFailure extends Error {
-    details;
-    retryable;
-    /** Machine-readable failure subdivision (SPEC §8), when the engine set one. */
-    code;
-    constructor(details, retryable, code) {
-        super(details);
-        this.name = "AgentFailure";
-        this.details = details;
-        this.retryable = retryable;
-        this.code = code;
-    }
-}
-export async function collect(events) {
-    let text = "";
-    for await (const e of events) {
-        if (e.type === "text")
-            text += e.delta;
-        else if (e.type === "completed")
-            return { text, data: e.data };
-        else if (e.type === "failed")
-            throw new AgentFailure(e.details, e.retryable, e.code);
-    }
-    throw new Error("stream ended without a terminal event"); // violates SPEC MUST 1
-}

package/dist/core.d.ts

@@ -1,13 +0,0 @@
-export type { Agent, AgentEvent, ImageRef, Json, Prompt, Scope } from "./agent.ts";
-export { ABORTED_CODE, MISSING_MODEL_CODE, SESSION_BUSY_CODE } from "./agent.ts";
-export { collect, AgentFailure, type CollectResult } from "./collect.ts";
-export type { ModuleLoadFailure } from "./loader.ts";
-export { createInvokeHandler } from "./channels/http.ts";
-export type { WireEvent } from "./channels/control.ts";
-export { ControlRequestError, connectAgent, connectSessionControl, type RemoteEndpointOptions, } from "./session-remote.ts";
-export { readBodyCapped } from "./channels/body.ts";
-export { text, textHeaders } from "./channels/respond.ts";
-export type { ChannelContext, ChannelHandler, ChannelModule, LongConnection, LongConnectionChannelModule, Routes, } from "./channel.ts";
-export { defineRoutine, type DefineRoutineOptions, type LoadedRoutine, type Routine } from "./schedule/routine.ts";
-export { defineChannel, type DefineChannelOptions } from "./channels/define-channel.ts";
-export type { DeclaredSecret } from "./declared-secrets.ts";

package/dist/core.js

@@ -1,15 +0,0 @@
-// VALUES, not types: each caller does something DIFFERENT with these codes (busy: retry with backoff, skip the
-// occurrence, or steer the live run instead of failing; aborted: settle a deliberate stop, never replay it;
-// missing_model: do not retry, give the session a model or the agent a default), which is why they are named at all.
-// Without an export an embedder copies the literal, and the copy is how the first-event rule goes silently wrong.
-export { ABORTED_CODE, MISSING_MODEL_CODE, SESSION_BUSY_CODE } from "./agent.js";
-export { collect, AgentFailure } from "./collect.js";
-export { createInvokeHandler } from "./channels/http.js";
-export { ControlRequestError, connectAgent, connectSessionControl, } from "./session-remote.js";
-export { readBodyCapped } from "./channels/body.js";
-export { text, textHeaders } from "./channels/respond.js";
-// Mounting only.
-export { defineRoutine } from "./schedule/routine.js";
-// What a `channels/*.ts` file is written against when it needs credentials: declaring them is what
-// lets `deploy` carry them and the serve refuse to start without them.
-export { defineChannel } from "./channels/define-channel.js";